01/03/2025

If the bugs are resolved, users will be able to operate the program without experiencing crashes.

Expected Results

Results

Bugs Fixed: Special thanks to David for stress-testing the program last week. The following issues have been resolved:

Next Steps

My next step is to address any bugs that David may encounter during testing. I’ll focus on stabilizing the modules with outstanding issues and create documentation that explains the current status of the codebase and protocol for packaging.

Files changed (57) hide show

README.md +75 -0
requirements.txt +18 -0
scripts/mac.spec +0 -69
src/controllers/FindTargetsController.py +84 -38
src/controllers/GenerateLibraryController.py +26 -15
src/controllers/HomeWindowController.py +314 -202
src/controllers/MainWindowController copy.py +0 -262
src/controllers/MainWindowController.py +284 -78
src/controllers/NCBIWindowController.py +14 -1
src/controllers/NewGenomeWindowController.py +111 -60
src/controllers/OffTargetController.py +12 -0
src/controllers/PopulationAnalysisWindowController.py +0 -6
src/controllers/StartupWindowController.py +67 -9
src/controllers/ViewTargetsController.py +265 -194
src/main.py +36 -6
src/models/AnnotationParser.py +63 -28
src/models/BaseModel.py +58 -0
src/models/ConfigManager.py +57 -10
src/models/DatabaseManager.py +283 -78
src/models/FindTargetsModel.py +21 -18
src/models/GenerateLibraryModel.py +174 -49
src/models/GlobalSettings.py +172 -33
src/models/HomeWindowModel.py +23 -22
src/models/NCBIWindowModel.py +23 -4
src/models/NewGenomeWindowModel.py +2 -2
src/models/OffTarget/local_output.txt +1 -29
src/models/OffTargetModel.py +18 -23
src/models/PopulationAnalysisWindowModel.py +0 -5
src/models/StartupWindowModel.py +24 -7
src/models/ViewTargetsModel.py +104 -124
src/ui/find_targets.ui +0 -25
src/ui/home_window.ui +45 -108
src/ui/main_window.ui +1 -26
src/ui/new_genome_window.ui +0 -34
src/ui/view_targets.ui +89 -64
src/views/CloseableTabWidget.py +43 -11
src/views/FindTargetsView.py +44 -18
src/views/GenerateLibraryView.py +24 -5
src/views/HomeWindowView.py +67 -38
src/views/LoadingDialog.py +9 -34
src/views/MultitargetingWindowView.py +10 -0
src/views/NCBIWindowView.py +38 -0
src/views/NewEndonucleaseView.py +16 -13
src/views/NewGenomeWindowView.py +10 -16
src/views/PopulationAnalysisWindowView.py +12 -25
src/views/StartupWindowView.py +2 -1
src/views/ViewTargetsView.py +334 -89
src/views/dialogs/base_insertion_dialog.py +56 -0
src/views/dna_viewer/__init__.py +1 -0
src/views/dna_viewer/components/__init__.py +1 -0
src/views/dna_viewer/components/feature_viewer.py +152 -0
src/views/dna_viewer/components/nucleotide_item.py +108 -0
src/views/dna_viewer/components/ruler.py +121 -0
src/views/dna_viewer/components/sequence_cursor.py +61 -0
src/views/dna_viewer/components/sequence_insertion_zone.py +356 -0
src/views/dna_viewer/components/sequence_viewer.py +438 -0
src/views/dna_viewer/dna_feature_viewer.py +309 -0

README.md CHANGED Viewed

@@ -20,3 +20,78 @@ Thank you for your interest in CASPER. Our packaged releases for Windows 10 and
 CASPER will launch and you will be good to go! If you have any problems, please email David Dooley at ddooley2@vols.utk.edu
 NOTE: CASPER may take a long time to launch for the first time due to initialization in the background. After the first launch, it should load much faster.

 CASPER will launch and you will be good to go! If you have any problems, please email David Dooley at ddooley2@vols.utk.edu
 NOTE: CASPER may take a long time to launch for the first time due to initialization in the background. After the first launch, it should load much faster.
+### Docker Installation (macOS)
+#### Prerequisites
+1. Install Docker Desktop for Mac
+   ```bash
+   brew install --cask docker
+   ```
+2. Install XQuartz
+   ```bash
+   brew install --cask xquartz
+   ```
+3. Configure XQuartz:
+   ```bash
+   # Start XQuartz
+   open -a XQuartz
+   # In XQuartz Preferences → Security:
+   # - Check "Allow connections from network clients"
+   # - Restart XQuartz after changing settings
+   ```
+4. Set up X11 forwarding (run these commands each time before starting the app):
+   ```bash
+   # Start XQuartz if not running
+   open -a XQuartz
+   # Get your IP address
+   export IP=$(ifconfig en0 | grep inet | awk '$1=="inet" {print $2}')
+   # Set up permissions (use your actual IP)
+   xhost + $IP
+   # Clean up any old containers
+   docker-compose down
+   ```
+5. Run CASPER:
+   ```bash
+   # First time or after making changes:
+   docker-compose up --build
+   # Subsequent runs (without rebuilding):
+   docker-compose up
+   # Or run in background:
+   docker-compose up -d
+   ```
+#### Troubleshooting
+- If the app doesn't start:
+  ```bash
+  # Stop all containers
+  docker-compose down
+  # Remove old containers and images
+  docker system prune -f
+  # Restart XQuartz
+  killall Xquartz
+  open -a XQuartz
+  # Set up X11 again
+  xhost + localhost
+  # Try running again
+  docker-compose up --build
+  ```
+- If you still have issues:
+  - Make sure Docker Desktop is running
+  - Try restarting your computer
+  - Run `docker-compose logs` to see detailed error messages

requirements.txt CHANGED Viewed

@@ -1,30 +1,48 @@
 beautifulsoup4==4.12.3
 biopython==1.84
 contourpy==1.3.0
 cycler==0.12.1
 darkdetect==0.7.1
 fonttools==4.53.1
 joblib==1.4.2
 kiwisolver==1.4.7
 lxml==5.3.0
 matplotlib==3.9.2
 mplcursors==0.5.3
 numpy==2.1.1
 packaging==24.1
 pandas==2.2.2
 pillow==10.4.0
 pyparsing==3.1.4
 PyQt6==6.7.1
 PyQt6-Qt6==6.7.2
 PyQt6_sip==13.8.0
 pyqtdarktheme==2.1.0
 python-dateutil==2.9.0.post0
 python-dotenv==1.0.1
 pytz==2024.1
 PyYAML==6.0.2
 scikit-learn==1.5.2
 scipy==1.14.1
 six==1.16.0
 soupsieve==2.6
 threadpoolctl==3.5.0
 tzdata==2024.1

+altgraph==0.17.4
+astroid==3.3.5
 beautifulsoup4==4.12.3
 biopython==1.84
+certifi==2024.8.30
+charset-normalizer==3.4.0
 contourpy==1.3.0
 cycler==0.12.1
 darkdetect==0.7.1
+dill==0.3.9
 fonttools==4.53.1
+graphviz==0.20.3
+idna==3.10
+isort==5.13.2
 joblib==1.4.2
 kiwisolver==1.4.7
 lxml==5.3.0
+macholib==1.16.3
 matplotlib==3.9.2
+mccabe==0.7.0
 mplcursors==0.5.3
 numpy==2.1.1
 packaging==24.1
 pandas==2.2.2
 pillow==10.4.0
+platformdirs==4.3.6
+pyinstaller==6.11.1
+pyinstaller-hooks-contrib==2024.10
+pylint==3.3.1
 pyparsing==3.1.4
 PyQt6==6.7.1
 PyQt6-Qt6==6.7.2
 PyQt6_sip==13.8.0
 pyqtdarktheme==2.1.0
+python-call-graph==2.1.2
 python-dateutil==2.9.0.post0
 python-dotenv==1.0.1
 pytz==2024.1
 PyYAML==6.0.2
+requests==2.32.3
 scikit-learn==1.5.2
 scipy==1.14.1
 six==1.16.0
 soupsieve==2.6
 threadpoolctl==3.5.0
+tomlkit==0.13.2
 tzdata==2024.1
+urllib3==2.2.3

scripts/mac.spec DELETED Viewed

@@ -1,69 +0,0 @@
-block_cipher = None
-a = Analysis(['src/main.py'],
-             pathex=['src'],
-             datas=[
-                ('assets', 'assets'),
-                ('config', 'config'),
-                ('logs', 'logs'),
-                ('src', 'src'),
-                ('genomeBrowserTemplate.html', '.'),
-             ],
-             hiddenimports=[],
-             hookspath=[],
-             runtime_hooks=[],
-             excludes=[],
-             win_no_prefer_redirects=False,
-             win_private_assemblies=False,
-             cipher=block_cipher,
-             noarchive=False)
-pyz = PYZ(a.pure, a.zipped_data,
-             cipher=block_cipher)
-exe = EXE(pyz,
-          a.scripts,
-          [],
-          exclude_binaries=True,
-          name='CASPERapp',
-          debug=False,
-          bootloader_ignore_signals=False,
-          strip=False,
-          upx=True,
-          console=False,
-          disable_windowed_traceback=False,
-          target_arch=None,
-          codesign_identity=None,
-          entitlements_file=None,
-          icon='assets/CASPER_icon.icns')
-coll = COLLECT(exe,
-               a.binaries,
-               a.zipfiles,
-               a.datas,
-               strip=False,
-               upx=True,
-               upx_exclude=[],
-               name='CASPERapp')
-app = BUNDLE(coll,
-             name='CASPERapp.app',
-             icon='assets/CASPER_icon.icns',
-             version='2.0.1',
-             bundle_identifier=None)
-# 1. Have the mac.spec in the app directory
-# 2. pyinstaller mac.spec
-# 3. mkdir -p dist/dmg
-# 4. rm -r dist/dmg/*
-# 5. Manual copy of the app into dist/dmg
-# 6. create-dmg \
-#   --volname "CASPERapp" \
-#   --window-pos 200 120 \
-#   --window-size 600 300 \
-#   --icon-size 100 \
-#   --icon "CASPERapp.app" 175 120 \
-#   --hide-extension "CASPERapp.app" \
-#   --app-drop-link 425 120 \
-#   "dist/CASPERapp.dmg" \
-#   "dist/dmg/"

src/controllers/FindTargetsController.py CHANGED Viewed

@@ -4,6 +4,7 @@ from views.FindTargetsView import FindTargetsView
 from PyQt6.QtWidgets import QMessageBox
 from views.LoadingDialog import LoadingDialog
 from PyQt6.QtWidgets import QApplication
 class FindTargetsController:
     def __init__(self, global_settings):
@@ -26,17 +27,28 @@ class FindTargetsController:
             self.global_settings.logger.debug(f"FindTargetsController received new annotation file: {new_annotation_file}")
             self._current_annotation_file = new_annotation_file
-            # Clear the current results
-            if self.view and hasattr(self.view, 'results_table'):
-                self.view.clear_results()
-                # If we have previous input data, rerun the search with the new annotation file
-                if self._input_data:
                     self._input_data['annotation_file'] = new_annotation_file
                     self._process_input_data(self._input_data)
         except Exception as e:
             self.global_settings.logger.error(f"Error handling annotation file change: {str(e)}")
     def _connect_signals(self):
         """Connect view signals"""
@@ -93,22 +105,35 @@ class FindTargetsController:
                 QMessageBox.warning(self.view, "No Selection", "Please select targets to view.")
                 return
-            # Create loading dialog
-            loading_dialog = LoadingDialog(self.view)
             loading_dialog.show()
             loading_dialog.set_progress(0)
             QApplication.processEvents()
             try:
-                # Find existing View Targets tab
-                main_window = self.global_settings.main_window
-                existing_tab = main_window.find_tab_by_title("View Targets")
                 loading_dialog.set_message("Initializing view targets...", 25)
                 QApplication.processEvents()
                 if existing_tab:
-                    view_targets_controller = main_window.tab_widgets['controllers'].get("View Targets")
                     if view_targets_controller:
                         loading_dialog.set_message("Loading guides...", 50)
                         QApplication.processEvents()
@@ -124,7 +149,7 @@ class FindTargetsController:
                         # Switch to the existing tab
                         main_window.view.tab_widget.setCurrentWidget(existing_tab)
                     else:
-                        self.logger.error("View Targets controller not found for existing tab")
                 else:
                     loading_dialog.set_message("Creating view targets...", 25)
                     QApplication.processEvents()
@@ -139,7 +164,7 @@ class FindTargetsController:
                         loading_dialog=loading_dialog
                     )
-                    main_window.open_new_tab("View Targets", view_targets_controller)
             finally:
                 loading_dialog.close()
@@ -168,34 +193,55 @@ class FindTargetsController:
     def open_view_targets_directly(self, input_data):
         """Open view targets directly for position-based searches"""
         try:
-            # Get targets using the model
-            targets = self.model.find_targets_by_position(
-                self.model._get_parser(self.model.get_cspr_file_path(input_data)),
-                input_data
-            )
-            if targets:
-                # Create view targets controller
-                view_targets_controller = self.global_settings.get_view_targets_window()
-                # Load targets directly
-                view_targets_controller.load_targets(
-                    targets,
-                    input_data['organism'],
-                    input_data['endonuclease']
                 )
-                # Open view targets tab
-                self.global_settings.main_window.open_new_tab(
-                    "View Targets",
-                    view_targets_controller
-                )
-            else:
-                QMessageBox.warning(
-                    self.view,
-                    "No Targets Found",
-                    "No targets were found in the specified position range."
-                )
         except Exception as e:
             self.global_settings.logger.error(f"Error opening view targets directly: {str(e)}")

 from PyQt6.QtWidgets import QMessageBox
 from views.LoadingDialog import LoadingDialog
 from PyQt6.QtWidgets import QApplication
+import os
 class FindTargetsController:
     def __init__(self, global_settings):
             self.global_settings.logger.debug(f"FindTargetsController received new annotation file: {new_annotation_file}")
             self._current_annotation_file = new_annotation_file
+            # Only process if we have a valid annotation file and input data
+            if new_annotation_file and self._input_data:
+                # Verify annotation file exists
+                annotation_path = os.path.join(self.global_settings.get_db_path(), 'GBFF', new_annotation_file)
+                if not os.path.isfile(annotation_path):
+                    # Try without GBFF subdirectory
+                    annotation_path = os.path.join(self.global_settings.get_db_path(), new_annotation_file)
+                    if not os.path.isfile(annotation_path):
+                        self.logger.warning(f"Annotation file not found at {annotation_path}")
+                        return
+                # Clear the current results
+                if self.view and hasattr(self.view, 'results_table'):
+                    self.view.clear_results()
+                    # Update input data with new annotation file
                     self._input_data['annotation_file'] = new_annotation_file
                     self._process_input_data(self._input_data)
         except Exception as e:
             self.global_settings.logger.error(f"Error handling annotation file change: {str(e)}")
+            # Don't raise the error since this is an event handler
     def _connect_signals(self):
         """Connect view signals"""
                 QMessageBox.warning(self.view, "No Selection", "Please select targets to view.")
                 return
+            # Create loading dialog with the main window as parent
+            main_window = self.global_settings.main_window
+            loading_dialog = LoadingDialog(main_window.view)
             loading_dialog.show()
             loading_dialog.set_progress(0)
             QApplication.processEvents()
             try:
+                # Get the current Find Targets tab number
+                current_tab_index = main_window.view.tab_widget.currentIndex()
+                current_tab_title = main_window.view.tab_widget.tabText(current_tab_index)
+                # Extract number from Find Targets tab (if any)
+                view_targets_title = "View Targets"
+                if current_tab_title != "Find Targets":
+                    try:
+                        number = current_tab_title.split()[-1]
+                        view_targets_title = f"View Targets {number}"
+                    except (IndexError, ValueError):
+                        pass
+                # Find existing View Targets tab with the same number
+                existing_tab = main_window.find_tab_by_title(view_targets_title)
                 loading_dialog.set_message("Initializing view targets...", 25)
                 QApplication.processEvents()
                 if existing_tab:
+                    view_targets_controller = main_window.tab_widgets['controllers'].get(view_targets_title)
                     if view_targets_controller:
                         loading_dialog.set_message("Loading guides...", 50)
                         QApplication.processEvents()
                         # Switch to the existing tab
                         main_window.view.tab_widget.setCurrentWidget(existing_tab)
                     else:
+                        self.logger.error(f"View Targets controller not found for existing tab {view_targets_title}")
                 else:
                     loading_dialog.set_message("Creating view targets...", 25)
                     QApplication.processEvents()
                         loading_dialog=loading_dialog
                     )
+                    main_window.open_new_tab(view_targets_title, view_targets_controller)
             finally:
                 loading_dialog.close()
     def open_view_targets_directly(self, input_data):
         """Open view targets directly for position-based searches"""
         try:
+            # Create loading dialog with the main window as parent
+            main_window = self.global_settings.main_window
+            loading_dialog = LoadingDialog(main_window.view)
+            loading_dialog.show()
+            loading_dialog.set_progress(0)
+            QApplication.processEvents()
+            try:
+                loading_dialog.set_message("Finding targets...", 25)
+                QApplication.processEvents()
+                # Get targets using the model
+                targets = self.model.find_targets_by_position(
+                    self.model._get_parser(self.model.get_cspr_file_path(input_data)),
+                    input_data
                 )
+                if targets:
+                    loading_dialog.set_message("Creating view targets...", 50)
+                    QApplication.processEvents()
+                    # Create view targets controller
+                    view_targets_controller = self.global_settings.get_view_targets_window()
+                    loading_dialog.set_message("Loading guides...", 75)
+                    QApplication.processEvents()
+                    # Load targets directly
+                    view_targets_controller.load_targets(
+                        targets,
+                        input_data['organism'],
+                        input_data['endonuclease']
+                    )
+                    # Open view targets tab
+                    self.global_settings.main_window.open_new_tab(
+                        "View Targets",
+                        view_targets_controller
+                    )
+                else:
+                    QMessageBox.warning(
+                        self.view,
+                        "No Targets Found",
+                        "No targets were found in the specified position range."
+                    )
+            finally:
+                loading_dialog.close()
+                QApplication.processEvents()
         except Exception as e:
             self.global_settings.logger.error(f"Error opening view targets directly: {str(e)}")

src/controllers/GenerateLibraryController.py CHANGED Viewed

@@ -13,10 +13,18 @@ class GenerateLibraryController(QObject):
         self.model = GenerateLibraryModel(global_settings)
         self.view = GenerateLibraryView(global_settings)
         # Get CSPR file path
-        if selected_targets and len(selected_targets) > 0:
             # Get organism name from the first target's chromosome
-            chrom = selected_targets[0].get('full_chromosome', '')
             if chrom:
                 # Extract organism name from chromosome ID
                 org_name = chrom.split('.')[0]
@@ -25,7 +33,7 @@ class GenerateLibraryController(QObject):
                 # Get CSPR file path and initialize parser
                 org_files = self.model.get_organism_to_files()
-                endonuclease = selected_targets[0].get('endonuclease', '').lower()
                 if org_name in org_files and endonuclease in org_files[org_name]:
                     cspr_file = os.path.join(
                         self.global_settings.get_db_path(),
@@ -35,7 +43,7 @@ class GenerateLibraryController(QObject):
                     # Get guide data for each target
                     processed_targets = []
-                    for target in selected_targets:
                         target_info = [{
                             'feature_id': target['feature_id'],
                             'feature_name': target['feature_name'],
@@ -63,11 +71,6 @@ class GenerateLibraryController(QObject):
                     self.selected_targets = processed_targets
                 else:
                     self.selected_targets = selected_targets
-        else:
-            self.selected_targets = selected_targets
-        # Log initialization
-        self.logger.debug(f"Initializing GenerateLibraryController with {len(selected_targets) if selected_targets else 0} targets")
         self._connect_signals()
@@ -75,15 +78,12 @@ class GenerateLibraryController(QObject):
         """Connect view signals to controller methods"""
         try:
             self.view.submit_clicked.connect(self._handle_submit)
-            self.logger.debug("Connected GenerateLibraryView signals")
         except Exception as e:
             self.logger.error(f"Error connecting signals: {str(e)}")
     def show(self):
         """Show the generate library window"""
         try:
-            self.logger.debug("Showing GenerateLibraryView")
             # Store reference to prevent garbage collection
             self.global_settings.main_window._current_generate_library_controller = self
@@ -184,13 +184,17 @@ class GenerateLibraryController(QObject):
                     else:
                         raise ValueError(f"Could not find organism {org_name} in database")
                 # Generate library using processed targets
                 success = self.model.generate_library(
                     self.processed_targets if hasattr(self, 'processed_targets') else self.selected_targets,
                     settings
                 )
-                if success:
                     self.view.show_success("Library generated successfully!")
                     self.view.close()
@@ -221,9 +225,16 @@ class GenerateLibraryController(QObject):
             if settings.get('find_off_targets'):
                 max_score = settings.get('max_off_target_score')
-                if max_score is None or not 0 < max_score <= 0.5:
-                    raise ValueError("Maximum off-target score must be between 0 and 0.5")
         except Exception as e:
             self.logger.error(f"Settings validation error: {str(e)}")
             raise

         self.model = GenerateLibraryModel(global_settings)
         self.view = GenerateLibraryView(global_settings)
+        # Get selected targets from global settings if not provided
+        if selected_targets is None and hasattr(self.global_settings, '_current_selected_targets'):
+            selected_targets = self.global_settings._current_selected_targets
+        self.selected_targets = selected_targets or []
+        self.view.ledFileName.setText('eck_12_spCas9_lib')
         # Get CSPR file path
+        if self.selected_targets and len(self.selected_targets) > 0:
             # Get organism name from the first target's chromosome
+            chrom = self.selected_targets[0].get('full_chromosome', '')
             if chrom:
                 # Extract organism name from chromosome ID
                 org_name = chrom.split('.')[0]
                 # Get CSPR file path and initialize parser
                 org_files = self.model.get_organism_to_files()
+                endonuclease = self.selected_targets[0].get('endonuclease', '').lower()
                 if org_name in org_files and endonuclease in org_files[org_name]:
                     cspr_file = os.path.join(
                         self.global_settings.get_db_path(),
                     # Get guide data for each target
                     processed_targets = []
+                    for target in self.selected_targets:
                         target_info = [{
                             'feature_id': target['feature_id'],
                             'feature_name': target['feature_name'],
                     self.selected_targets = processed_targets
                 else:
                     self.selected_targets = selected_targets
         self._connect_signals()
         """Connect view signals to controller methods"""
         try:
             self.view.submit_clicked.connect(self._handle_submit)
         except Exception as e:
             self.logger.error(f"Error connecting signals: {str(e)}")
     def show(self):
         """Show the generate library window"""
         try:
             # Store reference to prevent garbage collection
             self.global_settings.main_window._current_generate_library_controller = self
                     else:
                         raise ValueError(f"Could not find organism {org_name} in database")
+                # Connect to model's progress signal if off-target analysis is enabled
+                if settings.get('find_off_targets'):
+                    self.model.progress_updated.connect(self._handle_progress)
                 # Generate library using processed targets
                 success = self.model.generate_library(
                     self.processed_targets if hasattr(self, 'processed_targets') else self.selected_targets,
                     settings
                 )
+                if success and not settings.get('find_off_targets'):
                     self.view.show_success("Library generated successfully!")
                     self.view.close()
             if settings.get('find_off_targets'):
                 max_score = settings.get('max_off_target_score')
+                if max_score is None or not 0 <= max_score <= 0.5:
+                    raise ValueError("Maximum off-target score must be between 0 and 0.5 inclusive")
         except Exception as e:
             self.logger.error(f"Settings validation error: {str(e)}")
             raise
+    def _handle_progress(self, value):
+        """Handle progress updates from model"""
+        try:
+            self.view.progBar.setValue(value)
+        except Exception as e:
+            self.logger.error(f"Error updating progress: {str(e)}")

src/controllers/HomeWindowController.py CHANGED Viewed

@@ -7,69 +7,121 @@ from models.DatabaseManager import FileChangeType
 import time
 from views.LoadingDialog import LoadingDialog
 from PyQt6.QtWidgets import QApplication
 class HomeWindowController:
     def __init__(self, global_settings):
-        self.global_settings = global_settings
-        self.logger = global_settings.get_logger()
         try:
-            self.model = HomeWindowModel(global_settings)
-            self.view = HomeWindowView(global_settings)
-            self.init_ui()
-            self.setup_connections()
-            self.model.load_data()
-            self.global_settings.db_manager.db_files_changed.connect(self._handle_db_files_changed)
-            self.global_settings.db_manager.db_validation_changed.connect(self._handle_db_validation_changed)
-            self.global_settings.db_manager.db_state_changed.connect(self._handle_db_state_changed)
         except Exception as e:
-            show_error(self.global_settings, "Error initializing HomeWindowController", str(e))
-    def init_ui(self):
         try:
-            self.load_combo_box_data()
             self.handle_search_type_change()
         except Exception as e:
-            show_error(self.global_settings, "Error initializing UI in HomeWindowController", str(e))
-    def load_combo_box_data(self):
-        """Reload all combo box data"""
         try:
-            self.model.load_data()
-            organism_to_endonuclease = self.model.get_organism_to_endonuclease()
             annotation_files = self.model.get_annotation_files()
-            # Update organisms combo box
-            self.view.update_combo_box_organism(sorted(organism_to_endonuclease.keys()))
-            # Update endonuclease combo box
-            self.update_combo_box_endonuclease()
-            # Update annotation files combo box
             self.view.update_combo_box_annotation_files(annotation_files)
         except Exception as e:
-            show_error(self.global_settings, "Error loading dropdown data", str(e))
-    def update_combo_box_endonuclease(self):
-        selected_organism = self.view.combo_box_organism.currentText()
-        endonuclease = self.model.get_organism_to_endonuclease().get(selected_organism, [])
-        self.logger.debug(f"Updating endonuclease combo box for organism {selected_organism} with endonuclease: {endonuclease} in Main window")
-        self.view.update_combo_box_endonuclease(endonuclease)
-    def setup_connections(self):
         try:
             # grpNavigationMenu
-            self.view.push_button_new_genome.clicked.connect(self.open_new_genome_module)
-            self.view.push_button_new_endonuclease.clicked.connect(self.open_new_endonuclease_module)
-            self.view.push_button_multitargeting_analysis.clicked.connect(self.open_multitargeting_analysis_module)
-            self.view.push_button_population_analysis.clicked.connect(self.open_population_analysis_module)
             # grpStep1
-            self.view.combo_box_organism.currentIndexChanged.connect(self.update_combo_box_endonuclease)
             # grpStep2
-            self.view.push_button_ncbi_file_search.clicked.connect(self.open_ncbi_window)
             # grpStep3
             self.view.radio_button_feature.clicked.connect(self.handle_search_type_change)
@@ -79,40 +131,122 @@ class HomeWindowController:
             # Add connection for annotation file changes
             self.view.combo_box_local_annotation_files.currentTextChanged.connect(self._on_annotation_file_changed)
         except Exception as e:
-            show_error(self.global_settings, "Error setting up connections in HomeWindowController", str(e))
-    # Event Handlers
-    def gather_settings(self):
-        """Process input data and direct to appropriate view"""
         try:
-            input_data = self.view.get_find_targets_input()
-            if input_data['search_type'] == 'sequence':
-                sequence = input_data['search_query'].strip()
-                if len(sequence) < 100:
-                    QMessageBox.warning(
-                        self.view,
-                        "Sequence Too Short",
-                        "The sequence given is too small. At least 100 characters are required."
-                    )
-                    return
-                if len(sequence) > 10000:
-                    QMessageBox.warning(
-                        self.view,
-                        "Sequence Too Long",
-                        "The sequence given is too large. Maximum allowed length is 10,000 base pairs."
-                    )
-                    return
-                self.open_view_targets(input_data)
-            elif input_data['search_type'] == 'position':
-                self.open_view_targets(input_data)
-            else:
-                self.open_find_targets_module()
         except Exception as e:
-            show_error(self.global_settings, "Error in gather_settings", str(e))
     def open_view_targets(self, input_data):
         try:
@@ -124,7 +258,7 @@ class HomeWindowController:
             try:
                 # Create find targets controller to use its model
-                find_targets_controller = self.global_settings.get_find_targets_window()
                 # For position searches, handle each query separately
                 if input_data['search_type'] == 'position':
@@ -164,7 +298,7 @@ class HomeWindowController:
                     QApplication.processEvents()
                     # Close existing View Targets tab if it exists
-                    main_window = self.global_settings.main_window
                     existing_tab = main_window.find_tab_by_title("View Targets")
                     if existing_tab:
                         tab_index = main_window.view.tab_widget.indexOf(existing_tab)
@@ -174,7 +308,7 @@ class HomeWindowController:
                     # Create view targets controller
                     loading_dialog.set_message("Creating view targets...", 90)
                     QApplication.processEvents()
-                    view_targets_controller = self.global_settings.get_view_targets_window()
                     view_targets_controller.load_guides(
                         targets,
@@ -200,10 +334,10 @@ class HomeWindowController:
                 loading_dialog.close()
         except Exception as e:
-            self.global_settings.logger.error(f"Error opening view targets directly: {str(e)}")
-            show_error(self.global_settings, "Error", f"Could not open view targets: {str(e)}")
-    def open_find_targets_module(self):
         """Open find targets module for non-position searches"""
         try:
             # Show loading dialog
@@ -213,71 +347,112 @@ class HomeWindowController:
             QApplication.processEvents()
             try:
-                # Close existing Find Targets tab if it exists
-                main_window = self.global_settings.main_window
-                existing_tab = main_window.find_tab_by_title("Find Targets")
-                if existing_tab:
-                    tab_index = main_window.view.tab_widget.indexOf(existing_tab)
-                    main_window._close_tab(tab_index)
-                    self.logger.debug("Closed existing Find Targets tab")
                 loading_dialog.set_progress(40)
                 # Create new find targets controller and load data
-                find_targets_controller = self.global_settings.get_find_targets_window()
                 input_data = self.view.get_find_targets_input()
                 loading_dialog.set_progress(60)
                 find_targets_controller.find_targets(input_data)
                 loading_dialog.set_progress(80)
-                # Open new Find Targets tab
-                self.global_settings.main_window.open_new_tab("Find Targets", find_targets_controller)
                 loading_dialog.set_progress(100)
             finally:
                 loading_dialog.close()
         except Exception as e:
-            show_error(self.global_settings, "Error in open_find_targets_module() in Home", str(e))
-    def toggle_annotation(self):
-        # Implementation for toggling annotation
-        pass
-    def open_new_genome_module(self):
         try:
-            main_window = self.global_settings.main_window
             existing_tab = main_window.find_tab_by_title("New Genome")
             if existing_tab:
                 main_window.view.tab_widget.setCurrentWidget(existing_tab)
                 main_window._resize_for_tab("New Genome")
             else:
-                new_genome_controller = self.global_settings.get_new_genome_window()
                 main_window.open_new_tab("New Genome", new_genome_controller)
         except Exception as e:
-            show_error(self.global_settings, "Error in open_new_genome_widget() in Home", str(e))
-    def open_new_endonuclease_module(self):
         try:
-            main_window = self.global_settings.main_window
-            existing_tab = main_window.find_tab_by_title("Define New Endonuclease")
-            if existing_tab:
-                main_window.view.tab_widget.setCurrentWidget(existing_tab)
-                main_window._resize_for_tab("Define New Endonuclease")
-            else:
-                new_endonuclease_controller = self.global_settings.get_new_endonuclease_window()
-                main_window.open_new_tab("Define New Endonuclease", new_endonuclease_controller)
         except Exception as e:
-            show_error(self.global_settings, "Error in open_new_endonuclease_widget() in main", str(e))
-    def open_multitargeting_analysis_module(self):
         try:
             start_time = time.time()
             self.logger.debug("Starting multitargeting analysis module launch")
-            main_window = self.global_settings.main_window
             existing_tab = main_window.find_tab_by_title("Multitargeting Analysis")
             tab_check_time = time.time()
@@ -289,7 +464,7 @@ class HomeWindowController:
                 self.logger.debug(f"Switched to existing tab: {time.time() - tab_check_time:.2f} seconds")
             else:
                 controller_start = time.time()
-                multitargeting_controller = self.global_settings.get_multitargeting_window()
                 self.logger.debug(f"Controller creation took: {time.time() - controller_start:.2f} seconds")
                 tab_open_start = time.time()
@@ -298,119 +473,56 @@ class HomeWindowController:
             self.logger.debug(f"Total multitargeting module launch took: {time.time() - start_time:.2f} seconds")
         except Exception as e:
-            show_error(self.global_settings, "Error in open_multitargeting_analysis_widget() in Home", str(e))
-    def open_population_analysis_module(self):
         try:
-            main_window = self.global_settings.main_window
             existing_tab = main_window.find_tab_by_title("Population Analysis")
             if existing_tab:
                 main_window.view.tab_widget.setCurrentWidget(existing_tab)
                 main_window._resize_for_tab("Population Analysis")
             else:
-                population_analysis_controller = self.global_settings.get_population_analysis_window()
                 main_window.open_new_tab("Population Analysis", population_analysis_controller)
         except Exception as e:
-            show_error(self.global_settings, "Error in open_population_analysis_widget() in Home", str(e))
-    def launch_populate_fna_files(self):
-        # Implementation for launching populate FNA files
-        pass
-    def open_ncbi_window(self):
         try:
-            ncbi_controller = self.global_settings.get_ncbi_window()
-            self.global_settings.main_window.open_new_tab("NCBI Download Tool", ncbi_controller)
         except Exception as e:
-            show_error(self.global_settings, "Error in open_ncbi_window() in main", str(e))
-    def _handle_db_files_changed(self, changes):
-        """Handle database file changes"""
-        try:
-            # Reload model data if necessary
-            self.model.update_for_file_changes(changes)
-            # Update UI if needed
-            if (FileChangeType.CSPR_ADDED in changes or
-                FileChangeType.CSPR_REMOVED in changes):
-                # Update both organism and endonuclease combo boxes
-                organism_to_endonuclease = self.model.get_organism_to_endonuclease()
-                self.view.update_combo_box_organism(sorted(organism_to_endonuclease.keys()))
-                self.update_combo_box_endonuclease()
-            if (FileChangeType.GBFF_ADDED in changes or
-                FileChangeType.GBFF_REMOVED in changes):
-                self.view.update_combo_box_annotation_files(self.model.get_annotation_files())
-        except Exception as e:
-            show_error(self.global_settings, "Error handling database changes", str(e))
-    def _handle_db_validation_changed(self, is_valid, message):
-        """Handle database validation state changes"""
-        try:
-            if not is_valid:
-                self.view.show_warning("Database Warning", message)
-            # Update UI elements based on validation state
-            self.view.push_button_find_view_targets.setEnabled(is_valid)
-            self.view.push_button_multitargeting_analysis.setEnabled(is_valid)
-            self.view.push_button_population_analysis.setEnabled(is_valid)
-            # Log the validation state change
-            self.logger.debug(f"Database validation state changed to: {is_valid}")
-        except Exception as e:
-            self.logger.error(f"Error handling database validation change: {str(e)}")
-    def _handle_db_state_changed(self, is_valid, message, changes):
-        """Handle database state changes"""
         try:
-            if not is_valid:
-                show_error(self.global_settings, "Database Warning", message)
-                return
-            # Always reload model data when database state changes
-            self.model.load_data()
-            # Update all combo boxes
-            organism_to_endonuclease = self.model.get_organism_to_endonuclease()
-            self.view.update_combo_box_organism(sorted(organism_to_endonuclease.keys()))
-            self.update_combo_box_endonuclease()
-            self.view.update_combo_box_annotation_files(self.model.get_annotation_files())
         except Exception as e:
-            show_error(self.global_settings, "Error handling database state change", str(e))
-    def _check_and_update_home_tab(self, index):
-        if self.global_settings.main_window.view.tab_widget.tabText(index) == "Home":
-            self.load_combo_box_data()
-            # Disconnect after updating to avoid unnecessary updates
-            self.global_settings.main_window.view.tab_widget.currentChanged.disconnect(self._check_and_update_home_tab)
-    def get_organism_to_endonuclease(self):
-        return self.model.get_organism_to_endonuclease()
-    def get_annotation_files(self):
-        return self.model.get_annotation_files()
-    def get_annotation_file(self):
-        return self.view.get_annotation_file()
-    def _on_annotation_file_changed(self, new_file):
-        """Handle changes to the annotation file selection"""
-        self.global_settings.set_current_annotation_file(new_file)
-    def handle_search_type_change(self):
-        """Update UI elements based on search type"""
-        try:
-            search_type = self.view.get_search_type()
-            # Update button text
-            if search_type in ['position', 'sequence']:
-                self.view.push_button_find_view_targets.setText("View Targets")
-            else:  # 'feature'
-                self.view.push_button_find_view_targets.setText("Find Targets")
-        except Exception as e:
-            self.logger.error(f"Error updating search type UI: {str(e)}")

 import time
 from views.LoadingDialog import LoadingDialog
 from PyQt6.QtWidgets import QApplication
+from PyQt6.QtCore import Qt, QSize
 class HomeWindowController:
     def __init__(self, global_settings):
+        self.settings = global_settings
+        self.logger = self.settings.get_logger()
+        self.is_active = True
         try:
+            self.view = HomeWindowView(self.settings)
+            self.model = HomeWindowModel(self.settings)
+            self._setup_connections()
+            self._init_ui()
         except Exception as e:
+            show_error(self.settings, "Error initializing HomeWindowController", str(e))
+    def deactivate(self):
+        """Cleanup controller when deactivated"""
         try:
+            self.is_active = False
+            if hasattr(self, 'view'):
+                # Safely disconnect signals
+                try:
+                    self.settings.db_manager.db_state_changed.disconnect(self._on_db_state_changed)
+                except (TypeError, RuntimeError):
+                    # Signal wasn't connected or already disconnected
+                    pass
+                try:
+                    self.settings.db_manager.db_files_changed.disconnect(self._on_db_files_changed)
+                except (TypeError, RuntimeError):
+                    # Signal wasn't connected or already disconnected
+                    pass
+                # Delete view reference
+                delattr(self, 'view')
+        except Exception as e:
+            self.logger.error(f"Error in deactivate: {str(e)}")
+    def _init_ui(self):
+        """Initialize UI with current data"""
+        try:
+            self._update_ui_with_model_data()
             self.handle_search_type_change()
         except Exception as e:
+            show_error(self.settings, "Error initializing UI in HomeWindowController", str(e))
+    def _update_ui_with_model_data(self):
+        """Update all UI elements with current model data"""
         try:
+            # Get all required data at once
+            organism_data = self.model.get_organism_to_endonuclease()
             annotation_files = self.model.get_annotation_files()
+            # Update UI elements
+            self._update_organism_selection(organism_data)
+            self._update_annotation_files(annotation_files)
+        except Exception as e:
+            show_error(self.settings, "Error updating UI with model data", str(e))
+    def _update_organism_selection(self, organism_data, preserve_selection=True):
+        """Update organism and its dependent endonuclease selection"""
+        try:
+            # Store current selection if needed
+            current_organism = self.view.combo_box_organism.currentText() if preserve_selection else ""
+            # Block signals during update
+            with self._block_signals(self.view.combo_box_organism):
+                # Update organisms
+                self.view.update_combo_box_organism(sorted(organism_data.keys()))
+                # Restore or select first item
+                if preserve_selection and current_organism in organism_data:
+                    self.view.combo_box_organism.setCurrentText(current_organism)
+            # Update endonuclease based on current organism
+            self._update_endonuclease_for_organism(organism_data)
+        except Exception as e:
+            self.logger.error(f"Error updating organism selection: {str(e)}")
+    def _update_endonuclease_for_organism(self, organism_data):
+        """Update endonuclease combo box based on current organism"""
+        try:
+            selected_organism = self.view.combo_box_organism.currentText()
+            endonucleases = organism_data.get(selected_organism, [])
+            self.logger.debug(f"Updating endonuclease combo box for organism {selected_organism} with endonuclease: {endonucleases} in Main window")
+            self.view.update_combo_box_endonuclease(endonucleases)
+        except Exception as e:
+            self.logger.error(f"Error updating endonuclease selection: {str(e)}")
+    def _update_annotation_files(self, annotation_files):
+        """Update annotation files combo box"""
+        try:
             self.view.update_combo_box_annotation_files(annotation_files)
         except Exception as e:
+            self.logger.error(f"Error updating annotation files: {str(e)}")
+    def _on_organism_changed(self, _):
+        """Handle organism combo box changes"""
+        self._update_endonuclease_for_organism(self.model.get_organism_to_endonuclease())
+    def _setup_connections(self):
         try:
             # grpNavigationMenu
+            self.view.push_button_new_genome.clicked.connect(self.open_new_genome)
+            self.view.push_button_new_endonuclease.clicked.connect(self.open_new_endonuclease)
+            self.view.push_button_multitargeting_analysis.clicked.connect(self.open_multitargeting_analysis)
+            self.view.push_button_population_analysis.clicked.connect(self.open_population_analysis)
             # grpStep1
+            self.view.combo_box_organism.currentIndexChanged.connect(self._on_organism_changed)
             # grpStep2
+            self.view.push_button_ncbi_file_search.clicked.connect(self.open_ncbi)
             # grpStep3
             self.view.radio_button_feature.clicked.connect(self.handle_search_type_change)
             # Add connection for annotation file changes
             self.view.combo_box_local_annotation_files.currentTextChanged.connect(self._on_annotation_file_changed)
+            # Add connections for database changes
+            self.settings.db_manager.db_validation_changed.connect(self._on_db_validation_changed)
+            self.settings.db_manager.db_state_changed.connect(self._on_db_state_changed)
+            self.settings.db_manager.db_files_changed.connect(self._on_db_files_changed)
         except Exception as e:
+            show_error(self.settings, "Error setting up connections in HomeWindowController", str(e))
+    def _on_db_files_changed(self, changes):
+        """Handle database file changes"""
         try:
+            # Reload model data if necessary
+            self.model.update_for_file_changes(changes)
+            # Update UI based on change type
+            if self._should_update_organisms(changes):
+                self._update_organism_selection(self.model.get_organism_to_endonuclease())
+            if self._should_update_annotations(changes):
+                self._update_annotation_files(self.model.get_annotation_files())
+        except Exception as e:
+            show_error(self.settings, "Error handling database changes", str(e))
+    @staticmethod
+    def _should_update_organisms(changes):
+        """Check if organisms need to be updated based on changes"""
+        return (FileChangeType.CSPR_ADDED in changes or
+                FileChangeType.CSPR_REMOVED in changes)
+    @staticmethod
+    def _should_update_annotations(changes):
+        """Check if annotations need to be updated based on changes"""
+        return (FileChangeType.GBFF_ADDED in changes or
+                FileChangeType.GBFF_REMOVED in changes)
+    class _block_signals:
+        """Context manager for blocking Qt signals"""
+        def __init__(self, widget):
+            self.widget = widget
+        def __enter__(self):
+            self.widget.blockSignals(True)
+            return self.widget
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            self.widget.blockSignals(False)
+    def refresh_data(self):
+        """Refresh all data and update UI"""
+        try:
+            if not self.is_active or not hasattr(self, 'view'):
+                return
+            self.logger.debug("Refreshing home window data")
+            self.model.load_data()
+            self._update_ui_with_model_data()
+        except Exception as e:
+            self.logger.error(f"Error refreshing home window data: {str(e)}")
+    def _on_db_state_changed(self, is_valid, message, changes):
+        """Handle database state changes"""
+        try:
+            if not self.is_active or not hasattr(self, 'view'):
+                return
+            self.logger.debug(f"Database state changed - Valid: {is_valid}, Message: {message}")
+            if is_valid:
+                self.refresh_data()
+        except Exception as e:
+            self.logger.error(f"Error handling database state change: {str(e)}")
+    def _check_and_update_home_tab(self, index):
+        if self.settings.main_window.view.tab_widget.tabText(index) == "Home":
+            self.load_combo_box_data()
+            # Disconnect after updating to avoid unnecessary updates
+            self.settings.main_window.view.tab_widget.currentChanged.disconnect(self._check_and_update_home_tab)
+    def get_organism_to_endonuclease(self):
+        return self.model.get_organism_to_endonuclease()
+    def get_annotation_files(self):
+        return self.model.get_annotation_files()
+    def get_annotation_file(self):
+        return self.view.get_annotation_file()
+    def _on_annotation_file_changed(self, new_file):
+        """Handle changes to the annotation file selection"""
+        self.logger.debug(f"Current annotation file changed to: {new_file}")
+        self.settings.set_current_annotation_file(new_file)
+    def handle_search_type_change(self):
+        """Update UI elements based on search type"""
+        try:
+            search_type = self.view.get_search_type()
+            # Update button text
+            if search_type in ['position', 'sequence']:
+                self.view.push_button_find_view_targets.setText("View Targets")
+            else:  # 'feature'
+                self.view.push_button_find_view_targets.setText("Find Targets")
+        except Exception as e:
+            self.logger.error(f"Error updating search type UI: {str(e)}")
+    def _on_db_validation_changed(self, is_valid, message):
+        """Handle database validation changes"""
+        try:
+            if self.is_active and hasattr(self, 'view'):
+                if is_valid:
+                    self.refresh_data()
         except Exception as e:
+            self.logger.error(f"Error handling database validation change: {str(e)}")
     def open_view_targets(self, input_data):
         try:
             try:
                 # Create find targets controller to use its model
+                find_targets_controller = self.settings.get_find_targets_window()
                 # For position searches, handle each query separately
                 if input_data['search_type'] == 'position':
                     QApplication.processEvents()
                     # Close existing View Targets tab if it exists
+                    main_window = self.settings.main_window
                     existing_tab = main_window.find_tab_by_title("View Targets")
                     if existing_tab:
                         tab_index = main_window.view.tab_widget.indexOf(existing_tab)
                     # Create view targets controller
                     loading_dialog.set_message("Creating view targets...", 90)
                     QApplication.processEvents()
+                    view_targets_controller = self.settings.get_view_targets_window()
                     view_targets_controller.load_guides(
                         targets,
                 loading_dialog.close()
         except Exception as e:
+            self.settings.logger.error(f"Error opening view targets directly: {str(e)}")
+            show_error(self.settings, "Error", f"Could not open view targets: {str(e)}")
+    def open_find_targets(self):
         """Open find targets module for non-position searches"""
         try:
             # Show loading dialog
             QApplication.processEvents()
             try:
+                # Find all existing Find Targets tabs
+                main_window = self.settings.main_window
+                existing_tabs = []
+                tab_numbers = []
+                # Get all tab titles
+                for i in range(main_window.view.tab_widget.count()):
+                    tab_title = main_window.view.tab_widget.tabText(i)
+                    if tab_title.startswith("Find Targets"):
+                        existing_tabs.append(tab_title)
+                        # Extract number if it exists
+                        if tab_title != "Find Targets":
+                            try:
+                                num = int(tab_title.split()[-1])
+                                tab_numbers.append(num)
+                            except ValueError:
+                                continue
+                # Determine new tab number
+                new_tab_number = 1
+                if tab_numbers:
+                    new_tab_number = max(tab_numbers) + 1
                 loading_dialog.set_progress(40)
                 # Create new find targets controller and load data
+                find_targets_controller = self.settings.get_find_targets_window()
                 input_data = self.view.get_find_targets_input()
                 loading_dialog.set_progress(60)
                 find_targets_controller.find_targets(input_data)
                 loading_dialog.set_progress(80)
+                # Open new Find Targets tab with number if not the first one
+                tab_title = "Find Targets" if not existing_tabs else f"Find Targets {new_tab_number}"
+                self.settings.main_window.open_new_tab(tab_title, find_targets_controller)
                 loading_dialog.set_progress(100)
             finally:
                 loading_dialog.close()
         except Exception as e:
+            show_error(self.settings, "Error in open_find_targets() in Home", str(e))
+    def open_new_genome(self):
         try:
+            main_window = self.settings.main_window
             existing_tab = main_window.find_tab_by_title("New Genome")
             if existing_tab:
                 main_window.view.tab_widget.setCurrentWidget(existing_tab)
                 main_window._resize_for_tab("New Genome")
             else:
+                new_genome_controller = self.settings.get_new_genome_window()
                 main_window.open_new_tab("New Genome", new_genome_controller)
         except Exception as e:
+            show_error(self.settings, "Error in open_new_genome() in Home", str(e))
+    def open_new_endonuclease(self):
         try:
+            # Create new endonuclease controller
+            new_endonuclease_controller = self.settings.get_new_endonuclease_window()
+            # Get the window from the controller
+            window = new_endonuclease_controller.view
+            # Set window properties
+            window.setWindowModality(Qt.WindowModality.ApplicationModal)  # Make it modal
+            window.setMinimumSize(QSize(500, 650))  # Smaller minimum size
+            window.resize(QSize(600, 650))  # Set initial size
+            # Get the screen where the main window is
+            main_window = self.settings.main_window.view
+            screen = main_window.screen()
+            if not screen:
+                screen = QtWidgets.QApplication.primaryScreen()
+            # Get the available geometry of the screen (accounts for taskbars/docks)
+            screen_geometry = screen.availableGeometry()
+            # Calculate the center point of the screen
+            center_point = screen_geometry.center()
+            # Center the window on screen
+            window_geometry = window.frameGeometry()
+            window_geometry.moveCenter(center_point)
+            window.move(window_geometry.topLeft())
+            # Show the window
+            window.show()
+            window.raise_()
+            window.activateWindow()
+            # Store reference to prevent garbage collection
+            self._current_new_endonuclease_window = new_endonuclease_controller
+            self.logger.debug("New Endonuclease window opened successfully")
         except Exception as e:
+            show_error(self.settings, "Error opening new endonuclease window", str(e))
+    def open_multitargeting_analysis(self):
         try:
             start_time = time.time()
             self.logger.debug("Starting multitargeting analysis module launch")
+            main_window = self.settings.main_window
             existing_tab = main_window.find_tab_by_title("Multitargeting Analysis")
             tab_check_time = time.time()
                 self.logger.debug(f"Switched to existing tab: {time.time() - tab_check_time:.2f} seconds")
             else:
                 controller_start = time.time()
+                multitargeting_controller = self.settings.get_multitargeting_window()
                 self.logger.debug(f"Controller creation took: {time.time() - controller_start:.2f} seconds")
                 tab_open_start = time.time()
             self.logger.debug(f"Total multitargeting module launch took: {time.time() - start_time:.2f} seconds")
         except Exception as e:
+            show_error(self.settings, "Error in open_multitargeting_analysis() in Home", str(e))
+    def open_population_analysis(self):
         try:
+            main_window = self.settings.main_window
             existing_tab = main_window.find_tab_by_title("Population Analysis")
             if existing_tab:
                 main_window.view.tab_widget.setCurrentWidget(existing_tab)
                 main_window._resize_for_tab("Population Analysis")
             else:
+                population_analysis_controller = self.settings.get_population_analysis_window()
                 main_window.open_new_tab("Population Analysis", population_analysis_controller)
         except Exception as e:
+            show_error(self.settings, "Error in open_population_analysis() in Home", str(e))
+    def open_ncbi(self):
         try:
+            ncbi_controller = self.settings.get_ncbi_window()
+            self.settings.main_window.open_new_tab("NCBI Download Tool", ncbi_controller)
         except Exception as e:
+            show_error(self.settings, "Error in open_ncbi() in main", str(e))
+    # Event Handlers
+    def gather_settings(self):
+        """Process input data and direct to appropriate view"""
         try:
+            input_data = self.view.get_find_targets_input()
+            if input_data['search_type'] == 'sequence':
+                sequence = input_data['search_query'].strip()
+                if len(sequence) < 100:
+                    QMessageBox.warning(
+                        self.view,
+                        "Sequence Too Short",
+                        "The sequence given is too small. At least 100 characters are required."
+                    )
+                    return
+                if len(sequence) > 10000:
+                    QMessageBox.warning(
+                        self.view,
+                        "Sequence Too Long",
+                        "The sequence given is too large. Maximum allowed length is 10,000 base pairs."
+                    )
+                    return
+                self.open_view_targets(input_data)
+            elif input_data['search_type'] == 'position':
+                self.open_view_targets(input_data)
+            else:
+                self.open_find_targets()
         except Exception as e:
+            show_error(self.settings, "Error in gather_settings", str(e))

src/controllers/MainWindowController copy.py DELETED Viewed

@@ -1,262 +0,0 @@
-import os
-from PyQt6 import QtWidgets, QtCore
-from PyQt6.QtWidgets import QMainWindow
-from views.MainWindowView import MainWindowView
-from models.MainWindowModel import MainWindowModel
-from controllers.MultitargetingWindowController import MultitargetingWindowController
-from utils.ui import show_error, show_message, scale_ui, center_ui, position_window
-from utils.web import ncbi_page, repo_page, ncbi_blast_page
-from PyQt6.QtCore import QObject
-class MainWindowController(QObject):
-    def __init__(self, global_settings):
-        super().__init__()
-        self.global_settings = global_settings
-        self.logger = global_settings.get_logger()
-        try:
-            self.model = MainWindowModel(global_settings)
-            self.view = MainWindowView(global_settings)
-            # self.setup_connections()
-            # self.init_ui()
-            self.show()
-        except Exception as e:
-            show_error(global_settings, "Error initializing MainWindowController", str(e))
-            raise
-    def setup_connections(self):
-        try:
-            # menuBar
-            self.view.action_change_directory.triggered.connect(self.change_database_directory)
-            # self.view.action_exit.triggered.connect(self.close)
-            # self.view.action_open_genome_browser.triggered.connect(self.open_genome_browser)
-            self.view.action_open_repository.triggered.connect(self.open_repository_website)
-            self.view.action_open_NCBI_BLAST.triggered.connect(self.open_ncbi_blast_website)
-            self.view.action_open_NCBI.triggered.connect(self.open_ncbi_website)
-            # grpNavigationMenu
-            self.view.push_button_new_genome.clicked.connect(self.open_new_genome_widget)
-            self.view.push_button_new_endonuclease.clicked.connect(self.open_new_endonuclease_widget)
-            self.view.push_button_multitargeting_analysis.clicked.connect(self.open_multitargeting_analysis_widget)
-            self.view.push_button_population_analysis.clicked.connect(self.open_population_analysis_widget)
-            # grpStep1
-            self.view.combo_box_organism.currentIndexChanged.connect(self.update_combo_box_endonuclease)
-            # grpStep2
-            self.view.push_button_ncbi_file_search.clicked.connect(self.open_ncbi_window)
-            # grpStep3
-            self.view.radio_button_feature.clicked.connect(self.toggle_annotation)
-            self.view.radio_button_position.clicked.connect(self.toggle_annotation)
-            self.view.push_button_find_targets.clicked.connect(self.gather_settings)
-            self.view.push_button_view_targets.clicked.connect(self.view_results)
-            self.view.push_button_generate_library.clicked.connect(self.prep_gen_lib)
-            # self.view.theme_toggle_button.clicked.connect(self.toggle_theme)
-            # Custom title bar connections
-            self.view.theme_toggle_button.clicked.connect(self.toggle_theme)
-            self.view.minimize_button.clicked.connect(self.view.showMinimized)
-            self.view.maximize_button.clicked.connect(self.toggle_maximize)
-            self.view.close_button.clicked.connect(self.view.close)
-        except Exception as e:
-            show_error(self.global_settings, "Error setting up connections in MainWindowController", str(e))
-    def init_ui(self):
-        try:
-            self.view.push_button_view_targets.setEnabled(False)
-            self.view.push_button_generate_library.setEnabled(False)
-            self.load_combo_box_data()
-            self.view.reset_progress_bar()
-        except Exception as e:
-            show_error(self.global_settings, "Error initializing UI in MainWindowController", str(e))
-    def load_combo_box_data(self):
-        try:
-            self.model.load_data()
-            self.update_combo_box_data()
-        except Exception as e:
-            show_error(self.global_settings, "Error loading dropdown data in MainWindowController", str(e))
-    def update_combo_box_data(self):
-        organism_to_endonuclease = self.model.get_organism_to_endonuclease()
-        annotation_files = self.model.get_annotation_files()
-        self.logger.debug(f"Updating Organisms combo box with organisms: {organism_to_endonuclease.keys()} in Main window")
-        self.view.update_combo_box_organism(list(organism_to_endonuclease.keys()))
-        self.update_combo_box_endonuclease()
-        self.logger.debug(f"Updating Annotation files combo box with annotation files: {annotation_files} in Main window")
-        self.view.update_combo_box_annotation_files(annotation_files)
-    def update_combo_box_endonuclease(self):
-        selected_organism = self.view.combo_box_organism.currentText()
-        endonuclease = self.model.get_organism_to_endonuclease().get(selected_organism, [])
-        self.logger.debug(f"Updating endonuclease combo box for organism {selected_organism} with endonuclease: {endonuclease} in Main window")
-        self.view.update_combo_box_endonuclease(endonuclease)
-    # Event Handlers
-    def gather_settings(self):
-        # Implementation for gathering settings
-        pass
-    def view_results(self):
-        # Implementation for viewing results
-        pass
-    def toggle_annotation(self):
-        # Implementation for toggling annotation
-        pass
-    def prep_gen_lib(self):
-        # Implementation for preparing gene library
-        pass
-    def open_new_genome_widget(self):
-        try:
-            new_genome_window = self.global_settings.new_genome_window
-            self._open_widget("New Genome", new_genome_window.view)
-        except Exception as e:
-            show_error(self.global_settings, "Error in open_new_genome_widget() in main", e)
-    def open_new_endonuclease_widget(self):
-        try:
-            new_endo_window = self.global_settings.new_endonuclease_window
-            self._open_widget("New Endonuclease", new_endo_window.view)
-        except Exception as e:
-            show_error(self.global_settings, "Error in open_new_endonuclease_widget() in main", str(e))
-    def open_multitargeting_analysis_widget(self):
-        try:
-            multitargeting_window = self.global_settings.multitargeting_window
-            self._open_widget("Multitargeting Analysis", multitargeting_window)
-        except Exception as e:
-            show_error(self.global_settings, "Error in open_multitargeting_analysis_widget() in main", str(e))
-    def open_population_analysis_widget(self):
-        try:
-            population_analysis_window = self.global_settings.population_analysis_window
-            self._open_widget("Population Analysis", population_analysis_window)
-        except Exception as e:
-            show_error(self.global_settings, "Error in open_population_analysis_widget() in main", str(e))
-    def launch_populate_fna_files(self):
-        # Implementation for launching populate FNA files
-        pass
-    def open_ncbi_window(self):
-        try:
-            ncbi_window = self.global_settings.ncbi_window
-            self._open_widget("NCBI Window", ncbi_window.view)
-        except Exception as e:
-            show_error(self.global_settings, "Error in open_ncbi_window() in main", str(e))
-    def toggle_theme(self):
-        try:
-            self.global_settings.toggle_dark_mode()
-            self.view.update_theme_icon()
-            self.apply_theme()
-        except Exception as e:
-            self.logger.error(f"Error toggling theme: {str(e)}", exc_info=True)
-            show_error(self.global_settings, "Error toggling theme", str(e))
-    def toggle_maximize(self):
-        if self.view.isMaximized():
-            self.view.showNormal()
-        else:
-            self.view.showMaximized()
-    def apply_theme(self):
-        # Apply theme to all widgets
-        if self.global_settings.is_dark_mode():
-            # Apply dark theme
-            self.view.setStyleSheet("""
-                QWidget { background-color: #2b2b2b; color: #ffffff; }
-                QPushButton { background-color: #3a3a3a; border: 1px solid #5a5a5a; }
-                QPushButton:hover { background-color: #4a4a4a; }
-                QLineEdit, QTextEdit, QPlainTextEdit { background-color: #3a3a3a; border: 1px solid #5a5a5a; }
-                QComboBox { background-color: #3a3a3a; border: 1px solid #5a5a5a; }
-                QMenuBar { background-color: #2b2b2b; }
-                QMenuBar::item:selected { background-color: #3a3a3a; }
-                QMenu { background-color: #2b2b2b; }
-                QMenu::item:selected { background-color: #3a3a3a; }
-            """)
-        else:
-            # Apply light theme
-            self.view.setStyleSheet("""
-                QWidget { background-color: #f0f0f0; color: #000000; }
-                QPushButton { background-color: #e0e0e0; border: 1px solid #c0c0c0; }
-                QPushButton:hover { background-color: #d0d0d0; }
-                QLineEdit, QTextEdit, QPlainTextEdit { background-color: #ffffff; border: 1px solid #c0c0c0; }
-                QComboBox { background-color: #ffffff; border: 1px solid #c0c0c0; }
-                QMenuBar { background-color: #f0f0f0; }
-                QMenuBar::item:selected { background-color: #e0e0e0; }
-                QMenu { background-color: #f0f0f0; }
-                QMenu::item:selected { background-color: #e0e0e0; }
-            """)
-    # Utility Functions
-    def some_long_running_task(self):
-        if self.view.progress_bar:
-            self.view.reset_progress()
-        # ... (perform task steps)
-        if self.view.progress_bar:
-            self.view.set_progress(50)
-        # ... (more task steps)
-        if self.view.progress_bar:
-            self.view.set_progress(100)
-    def show(self):
-        try:
-            saved_position = self.global_settings.load_window_position("main_window")
-            if saved_position:
-                self.view.move(saved_position)
-            else:
-                center_ui(self.view)
-            self.view.show()
-            self.apply_theme()
-        except Exception as e:
-            self.global_settings.logger.error(f"Error showing main window: {str(e)}", exc_info=True)
-            show_error(self.global_settings, "Error showing main window", e)
-    def closeEvent(self, event):
-        self.global_settings.save_window_position("main_window", self.view.pos())
-        event.accept()
-    def change_database_directory(self):
-        try:
-            new_directory = QtWidgets.QFileDialog.getExistingDirectory(
-                self.view, "Select Database Directory", self.global_settings.CSPR_DB,
-                QtWidgets.QFileDialog.Option.ShowDirsOnly
-            )
-            if new_directory:
-                if self.global_settings.validate_db_path(new_directory):
-                    self.global_settings.save_database_path(new_directory)
-                    self.global_settings.initialize_app_directories()
-                    self.load_combo_box_data()
-                    show_message(12, QtWidgets.QMessageBox.Icon.Information,
-                                 "Success", "Database directory changed successfully.")
-                else:
-                    show_message(12, QtWidgets.QMessageBox.Icon.Warning,
-                                 "Invalid Directory", "The selected directory does not contain valid CSPR files.")
-        except Exception as e:
-            self.logger.error(f"Error changing database directory: {str(e)}", exc_info=True)
-            show_error(self.global_settings, "Error changing database directory", str(e))
-    def open_ncbi_website(self):
-        ncbi_page()
-    def open_repository_website(self):
-        repo_page()
-    def open_ncbi_blast_website(self):
-        ncbi_blast_page()
-    def _open_widget(self, title, widget) -> None:
-        index = self.view.stacked_widget.indexOf(widget)
-        if index == -1:
-            self.view.stacked_widget.addWidget(widget)
-            index = self.view.stacked_widget.indexOf(widget)
-        self.view.stacked_widget.setCurrentIndex(index)
-        # Make sure the stacked widget is visible
-        self.view.stacked_widget.show()

src/controllers/MainWindowController.py CHANGED Viewed

@@ -22,12 +22,28 @@ class MainWindowController(LoggingMixin):
         self.startup_size = QSize(750, 550)
         self.current_tab = None
         self.previous_size = None
         try:
             self.view = MainWindowView(self.settings)
             self._setup_connections()
             self._init_ui()
             self.settings.check_and_emit_first_time_startup()
         except Exception as e:
             self.log_error("__init__", e)
             show_error(self.settings, "Error initializing MainWindowController", str(e))
@@ -43,21 +59,25 @@ class MainWindowController(LoggingMixin):
         # Tab bar
         self.view.tab_widget.tab_closed.connect(self._on_tab_closed)
-        self.view.tab_widget.tabCloseRequested.connect(self._close_tab)
         self.view.tab_widget.currentChanged.connect(self._on_current_tab_changed)
         self.settings.first_time_startup.connect(self._handle_first_time_startup)
         # Add Button Menu
-        # self.view.action_new_genome.triggered.connect(self.open_new_genome_tab)
-        # self.view.action_new_endonuclease.triggered.connect(self.open_new_endonuclease_tab)
         # Settings Menu
         self.view.action_toggle_theme.triggered.connect(self._toggle_theme)
     def _init_ui(self):
         self.log_method_call("_init_ui")
         if self.is_first_time_startup:
             self.log_info("First time startup detected. Opening startup tab.")
             self._open_startup_tab()
@@ -66,21 +86,46 @@ class MainWindowController(LoggingMixin):
         db_path = self.settings.get_db_path()
         is_valid, message = self.settings.validate_db_path(db_path)
-        if db_path and is_valid:
-            self.log_info(f"Database path is valid: {db_path}")
-            self._open_home_tab()
-        else:
             self.log_warning(f"Invalid database path: {db_path}. {message}")
-            self._open_startup_tab()
     def _handle_first_time_startup(self):
         self.log_info("First time startup signal received")
         self.is_first_time_startup = True
         self._open_startup_tab()
-    def _open_startup_tab(self):
         try:
-            self.startup_controller = self.settings.get_startup_window()
             self.open_new_tab("Startup", self.startup_controller)
         except Exception as e:
             self.log_error("_open_startup_tab", e)
@@ -109,12 +154,29 @@ class MainWindowController(LoggingMixin):
         self._center_window()
     def _center_window(self):
         try:
-            center_point = QtGui.QGuiApplication.primaryScreen().availableGeometry().center()
             frame_geometry = self.view.frameGeometry()
             frame_geometry.moveCenter(center_point)
             self.view.move(frame_geometry.topLeft())
-            self.log_debug(f"Window centered at {self.view.pos()}")
         except Exception as e:
             self.log_error("_center_window", e)
             show_error(self.settings, "Error centering window", str(e))
@@ -141,22 +203,87 @@ class MainWindowController(LoggingMixin):
             show_error(self.settings, "Error changing database directory", str(e))
     def _handle_invalid_directory(self, new_directory, message):
         reply = QtWidgets.QMessageBox.question(
             self.view,
             "Invalid Directory",
-            f"The selected directory does not contain valid CSPR files: {message}\n\n"
-            "Would you like to analyze a new genome in this directory?",
             QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No,
             QtWidgets.QMessageBox.StandardButton.No
         )
         if reply == QtWidgets.QMessageBox.StandardButton.Yes:
-            self.settings.save_db_path(new_directory)
-            self.settings.update_db_state()
-            self.open_new_genome_tab()
         else:
             show_message("Operation Cancelled", "Database directory change cancelled.")
     def _process_valid_directory(self, new_directory):
         try:
             self.settings.save_db_path(new_directory)
@@ -215,7 +342,7 @@ class MainWindowController(LoggingMixin):
             if existing_tab:
                 self.log_debug(f"Tab '{title}' already exists, switching to it")
                 self.view.tab_widget.setCurrentWidget(existing_tab)
-                self._resize_for_tab(title)
                 return
             # Create widget from content
@@ -237,87 +364,85 @@ class MainWindowController(LoggingMixin):
             self.view.tab_widget.setCurrentIndex(index)
             self.tab_widgets['widgets'][title] = wrapper
-            self._resize_for_tab(title)
             self.log_info(f"Tab '{title}' opened successfully at index {index}")
         except Exception as e:
             self.log_error("open_new_tab", e)
             show_error(self.settings, f"Error opening tab '{title}'", str(e))
-    def _resize_for_tab(self, title):
         try:
             if title == "Startup":
-                # For Startup tab, set fixed size but keep window controls
-                self.view.setFixedSize(self.startup_size)
-            elif title in ["View Targets", "Multitargeting Analysis"]:
-                # Store current size before applying constraints
-                if self.current_tab not in ["View Targets", "Multitargeting Analysis"]:
                     self.previous_size = self.view.size()
-                # Set minimum dimensions for these tabs
-                min_width = 1300
-                min_height = 800
                 # Calculate new dimensions
-                new_width = max(self.view.width(), min_width)
-                new_height = max(self.view.height(), min_height)
                 # Only resize if dimensions need to increase
                 if new_width > self.view.width() or new_height > self.view.height():
                     self.view.resize(QSize(new_width, new_height))
-                # Set minimum size constraints
-                self.view.setMinimumSize(QSize(min_width, min_height))
-                self.view.setMaximumSize(QtCore.QSize(16777215, 16777215))
-            else:
-                # For all other tabs
-                self.view.setMinimumSize(QSize(400, 300))
                 self.view.setMaximumSize(QtCore.QSize(16777215, 16777215))
-                # Restore previous size if available and coming from View Targets or Multi-targeting Analysis
-                if self.current_tab in ["View Targets", "Multitargeting Analysis"] and self.previous_size:
-                    self.view.resize(self.previous_size)
                 elif self.current_tab == "Startup" or self.view.size() == self.startup_size:
                     self.view.resize(self.shared_tab_size)
             # Update the current tab
             self.current_tab = title
         except Exception as e:
             self.log_error("_resize_for_tab", e)
     def _close_tab(self, index):
         """Handle tab closure using CloseableTabWidget"""
-        if 0 <= index < self.view.tab_widget.count():
-            title = self.view.tab_widget.tabText(index)
-            # Store size before closing View Targets tab
-            if title == "View Targets":
-                self.previous_size = self.view.size()
-            # Let CloseableTabWidget handle the widget cleanup
-            self.view.tab_widget.closeTab(index)
-            # Clean up references
-            if title in self.tab_widgets['widgets']:
-                del self.tab_widgets['widgets'][title]
-            if title in self.tab_widgets['controllers']:
-                del self.tab_widgets['controllers'][title]
-            self.logger.debug(f"Closed tab '{title}' at index {index}")
-            # Handle post-close operations
-            if title == "New Genome":
-                home_tab = self.find_tab_by_title("Home")
-                if home_tab:
-                    home_controller = self.settings.get_home_window()
-                    home_controller.refresh_data()
-            # Resize for the current tab
-            if self.view.tab_widget.count() > 0:
-                new_index = self.view.tab_widget.currentIndex()
-                new_tab_title = self.view.tab_widget.tabText(new_index)
-                self._resize_for_tab(new_tab_title)
     def _toggle_theme(self):
         try:
@@ -332,11 +457,11 @@ class MainWindowController(LoggingMixin):
             saved_position = self.settings.load_window_position("main_window")
             if saved_position:
                 self.view.move(saved_position)
-            else:
-                # center_ui(self.view)
-                pass
             self.view.show()
             self.view.apply_theme()
         except Exception as e:
             self.log_error("show", e)
             show_error(self.settings, "Error showing main window", e)
@@ -410,20 +535,101 @@ class MainWindowController(LoggingMixin):
                 if old_tab_title and old_tab_title != "Startup":
                     self.previous_size = self.view.size()
-                self._resize_for_tab(new_tab_title)
         except Exception as e:
             self.log_error("_on_current_tab_changed", e)
-    def open_new_endonuclease_tab(self):
-        """Opens the new endonuclease window"""
         try:
             new_endonuclease_controller = self.settings.get_new_endonuclease_window()
-            new_endonuclease_controller.view.show()  # Show as window instead of tab
         except Exception as e:
-            self.log_error("open_new_endonuclease_tab", e)
             show_error(self.settings, "Error opening new endonuclease window", str(e))

         self.startup_size = QSize(750, 550)
         self.current_tab = None
         self.previous_size = None
+        # Add flag to track dialog state
+        self._cspr_deletion_dialog_shown = False
+        # Define minimum sizes for different tab types
+        self.tab_min_sizes = {
+            "Startup": QSize(750, 550),  # Startup has a fixed size
+            "View Targets": QSize(1300, 800),  # Large tabs
+            "Multitargeting Analysis": QSize(1300, 800),
+            "Population Analysis": QSize(1000, 700),  # Medium-large tabs
+            "Find Targets": QSize(1000, 700),
+            "New Genome": QSize(800, 600),  # Medium tabs
+            "Home": QSize(800, 600),
+            "default": QSize(600, 500)  # Default minimum size for any other tab
+        }
         try:
             self.view = MainWindowView(self.settings)
             self._setup_connections()
             self._init_ui()
             self.settings.check_and_emit_first_time_startup()
+            # Center the window after initialization
+            self._center_window()
         except Exception as e:
             self.log_error("__init__", e)
             show_error(self.settings, "Error initializing MainWindowController", str(e))
         # Tab bar
         self.view.tab_widget.tab_closed.connect(self._on_tab_closed)
+        self.view.tab_widget.tab_closing.connect(self._close_tab)
         self.view.tab_widget.currentChanged.connect(self._on_current_tab_changed)
         self.settings.first_time_startup.connect(self._handle_first_time_startup)
         # Add Button Menu
+        self.view.action_new_endonuclease.triggered.connect(self.open_new_endonuclease_window)
         # Settings Menu
         self.view.action_toggle_theme.triggered.connect(self._toggle_theme)
+        # Database state changes
+        self.settings.db_manager.db_state_changed.connect(self._on_db_state_changed)
+        self.settings.db_manager.db_validation_changed.connect(self._on_db_validation_changed)
     def _init_ui(self):
         self.log_method_call("_init_ui")
+        # Check if it's first time startup
         if self.is_first_time_startup:
             self.log_info("First time startup detected. Opening startup tab.")
             self._open_startup_tab()
         db_path = self.settings.get_db_path()
         is_valid, message = self.settings.validate_db_path(db_path)
+        if not is_valid:
             self.log_warning(f"Invalid database path: {db_path}. {message}")
+            # Always open startup tab for invalid paths, keeping the existing path
+            self._open_startup_tab(keep_db_path=True)
+            return  # Add explicit return to prevent further execution
+        self.log_info(f"Database path is valid: {db_path}")
+        self._open_home_tab()
     def _handle_first_time_startup(self):
         self.log_info("First time startup signal received")
         self.is_first_time_startup = True
         self._open_startup_tab()
+    def _open_startup_tab(self, keep_db_path=False):
         try:
+            # First safely deactivate any existing controllers
+            for title, controller in list(self.tab_widgets['controllers'].items()):
+                try:
+                    if hasattr(controller, 'deactivate'):
+                        controller.deactivate()
+                except Exception as e:
+                    self.logger.error(f"Error deactivating controller for {title}: {str(e)}")
+            # Force close all tabs
+            while self.view.tab_widget.count() > 0:
+                try:
+                    widget = self.view.tab_widget.widget(0)
+                    self.view.tab_widget.removeTab(0)
+                    if widget:
+                        widget.deleteLater()
+                except Exception as e:
+                    self.logger.error(f"Error closing tab: {str(e)}")
+            # Clear tab tracking dictionaries
+            self.tab_widgets['widgets'].clear()
+            self.tab_widgets['controllers'].clear()
+            # Then open the startup tab
+            self.startup_controller = self.settings.get_startup_window(keep_db_path=keep_db_path)
             self.open_new_tab("Startup", self.startup_controller)
         except Exception as e:
             self.log_error("_open_startup_tab", e)
         self._center_window()
     def _center_window(self):
+        """Center the window on the current screen"""
         try:
+            # Get the current screen where the window is or the primary screen
+            window_screen = self.view.screen()
+            if not window_screen:
+                window_screen = QtGui.QGuiApplication.primaryScreen()
+            # Get the geometry of the screen
+            screen_geometry = window_screen.availableGeometry()
+            # Calculate the center point
+            center_point = screen_geometry.center()
+            # Get the window geometry
             frame_geometry = self.view.frameGeometry()
+            # Move the window's center to the screen's center
             frame_geometry.moveCenter(center_point)
+            # Move the window to the calculated position
             self.view.move(frame_geometry.topLeft())
+            self.log_debug(f"Window centered on screen at {self.view.pos()}")
         except Exception as e:
             self.log_error("_center_window", e)
             show_error(self.settings, "Error centering window", str(e))
             show_error(self.settings, "Error changing database directory", str(e))
     def _handle_invalid_directory(self, new_directory, message):
+        """Handle invalid directory selection with option to analyze new genomes"""
+        self.logger.debug("Entering _handle_invalid_directory")  # Add entry log
+        # Always show error for non-existent directories
+        if message == "The selected directory does not exist.":
+            self.logger.debug("Directory does not exist, showing error")  # Add debug log
+            show_error(self.settings, "Invalid Directory", message)
+            return
+        self.logger.debug("Showing analyze new genome dialog")  # Add debug log
+        # Show dialog for analyzing new genome
         reply = QtWidgets.QMessageBox.question(
             self.view,
             "Invalid Directory",
+            "Would you like to analyze a new genome in this directory? testing",
             QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No,
             QtWidgets.QMessageBox.StandardButton.No
         )
+        self.logger.debug(f"User reply to analyze new genome: {reply == QtWidgets.QMessageBox.StandardButton.Yes}")  # Add debug log
         if reply == QtWidgets.QMessageBox.StandardButton.Yes:
+            self.logger.debug("User chose to analyze new genome")  # Add debug log
+            # Temporarily disconnect validation signal to prevent warning
+            self.settings.db_manager.db_validation_changed.disconnect()
+            try:
+                # Set directory change flag
+                self.settings.db_manager.is_changing_directory = True
+                self.logger.debug(f"Starting directory change process to: {new_directory}")
+                # Save the new path without switching to startup tab
+                self.settings.save_db_path(new_directory)
+                self.settings.update_db_state()
+                # Store the new directory for later use
+                self._pending_directory_change = new_directory
+                # Open new genome tab without closing other tabs
+                self.logger.debug("Opening new genome tab")  # Add debug log
+                self.open_new_genome_tab()
+                # Connect to the new genome tab's completion signal
+                new_genome_tab = self.find_tab_by_title("New Genome")
+                if new_genome_tab and new_genome_tab in self.tab_widgets['controllers']:
+                    new_genome_controller = self.tab_widgets['controllers']["New Genome"]
+                    new_genome_controller.process_completed.connect(self._on_new_genome_completed)
+                    self.logger.debug("Connected to new genome completion signal")  # Add debug log
+            except Exception as e:
+                self.logger.error(f"Error in _handle_invalid_directory: {str(e)}")  # Add error log
+                raise
+            finally:
+                # Reconnect the signal after operation is complete
+                self.settings.db_manager.db_validation_changed.connect(self._on_db_validation_changed)
+                self.logger.debug("Reconnected validation signal")  # Add debug log
         else:
+            self.logger.debug("User cancelled new genome analysis")  # Add debug log
             show_message("Operation Cancelled", "Database directory change cancelled.")
+    def _on_new_genome_completed(self):
+        """Handle completion of new genome analysis"""
+        try:
+            if hasattr(self, '_pending_directory_change'):
+                # Show success message
+                show_message(
+                    "Database Directory Change Complete",
+                    f"Successfully changed database directory to:\n{self._pending_directory_change}",
+                    QtWidgets.QMessageBox.Icon.Information
+                )
+                # Refresh home tab
+                home_tab = self.find_tab_by_title("Home")
+                if home_tab and home_tab in self.tab_widgets['controllers']:
+                    home_controller = self.tab_widgets['controllers']["Home"]
+                    home_controller.refresh_data()
+                # Clean up
+                delattr(self, '_pending_directory_change')
+        except Exception as e:
+            self.logger.error(f"Error handling new genome completion: {str(e)}")
     def _process_valid_directory(self, new_directory):
         try:
             self.settings.save_db_path(new_directory)
             if existing_tab:
                 self.log_debug(f"Tab '{title}' already exists, switching to it")
                 self.view.tab_widget.setCurrentWidget(existing_tab)
+                self._resize_for_tab(title, center_window=False)  # Don't center when switching to existing tab
                 return
             # Create widget from content
             self.view.tab_widget.setCurrentIndex(index)
             self.tab_widgets['widgets'][title] = wrapper
+            self._resize_for_tab(title, center_window=True)  # Center when opening new tab
             self.log_info(f"Tab '{title}' opened successfully at index {index}")
         except Exception as e:
             self.log_error("open_new_tab", e)
             show_error(self.settings, f"Error opening tab '{title}'", str(e))
+    def _resize_for_tab(self, title, center_window=True):
+        """Handle window resizing for different tab types"""
         try:
+            # Get the minimum size for this tab type
+            min_size = self.tab_min_sizes.get(title, self.tab_min_sizes["default"])
             if title == "Startup":
+                # Startup tab has a fixed size
+                self.view.setFixedSize(min_size)
+            else:
+                # Store current size before applying constraints if coming from a different size category
+                current_min_size = self.tab_min_sizes.get(self.current_tab, self.tab_min_sizes["default"])
+                if current_min_size != min_size:
                     self.previous_size = self.view.size()
                 # Calculate new dimensions
+                new_width = max(self.view.width(), min_size.width())
+                new_height = max(self.view.height(), min_size.height())
                 # Only resize if dimensions need to increase
                 if new_width > self.view.width() or new_height > self.view.height():
                     self.view.resize(QSize(new_width, new_height))
+                # Set size constraints
+                self.view.setMinimumSize(min_size)
                 self.view.setMaximumSize(QtCore.QSize(16777215, 16777215))
+                # Restore previous size if available and coming from a larger minimum size tab
+                if self.current_tab and self.previous_size:
+                    current_min_size = self.tab_min_sizes.get(self.current_tab, self.tab_min_sizes["default"])
+                    if current_min_size.width() > min_size.width() or current_min_size.height() > min_size.height():
+                        # Only restore if the previous size is larger than our minimum
+                        if (self.previous_size.width() >= min_size.width() and
+                            self.previous_size.height() >= min_size.height()):
+                            self.view.resize(self.previous_size)
                 elif self.current_tab == "Startup" or self.view.size() == self.startup_size:
                     self.view.resize(self.shared_tab_size)
             # Update the current tab
             self.current_tab = title
+            # Center the window after resizing only if requested
+            if center_window:
+                self._center_window()
         except Exception as e:
             self.log_error("_resize_for_tab", e)
     def _close_tab(self, index):
         """Handle tab closure using CloseableTabWidget"""
+        try:
+            if 0 <= index < self.view.tab_widget.count():
+                title = self.view.tab_widget.tabText(index)
+                # Safely deactivate controller if it exists
+                if title in self.tab_widgets['controllers']:
+                    try:
+                        controller = self.tab_widgets['controllers'][title]
+                        if hasattr(controller, 'deactivate'):
+                            controller.deactivate()
+                    except Exception as e:
+                        self.logger.error(f"Error deactivating controller for {title}: {str(e)}")
+                # Clean up references
+                if title in self.tab_widgets['widgets']:
+                    del self.tab_widgets['widgets'][title]
+                if title in self.tab_widgets['controllers']:
+                    del self.tab_widgets['controllers'][title]
+                self.logger.debug(f"Closed tab '{title}' at index {index}")
+        except Exception as e:
+            self.logger.error(f"Error in _close_tab: {str(e)}")
     def _toggle_theme(self):
         try:
             saved_position = self.settings.load_window_position("main_window")
             if saved_position:
                 self.view.move(saved_position)
             self.view.show()
             self.view.apply_theme()
+            # Center the window after showing it
+            self._center_window()
+            print("Window initialized")
         except Exception as e:
             self.log_error("show", e)
             show_error(self.settings, "Error showing main window", e)
                 if old_tab_title and old_tab_title != "Startup":
                     self.previous_size = self.view.size()
+                self._resize_for_tab(new_tab_title, center_window=False)
         except Exception as e:
             self.log_error("_on_current_tab_changed", e)
+    def open_new_endonuclease_window(self):
+        """Opens the new endonuclease as a separate window"""
         try:
+            # Create the controller
             new_endonuclease_controller = self.settings.get_new_endonuclease_window()
+            # Get the window from the controller
+            window = new_endonuclease_controller.view
+            # Set window properties
+            window.setWindowModality(Qt.WindowModality.ApplicationModal)  # Make it modal
+            window.setMinimumSize(QSize(800, 600))  # Set minimum size
+            # Center the window relative to the main window
+            main_window_center = self.view.geometry().center()
+            window_geometry = window.frameGeometry()
+            window_geometry.moveCenter(main_window_center)
+            window.move(window_geometry.topLeft())
+            # Show the window
+            window.show()
+            window.raise_()
+            window.activateWindow()
+            # Store reference to prevent garbage collection
+            self._current_new_endonuclease_window = new_endonuclease_controller
+            self.log_info("New Endonuclease window opened successfully")
         except Exception as e:
+            self.log_error("open_new_endonuclease_window", e)
             show_error(self.settings, "Error opening new endonuclease window", str(e))
+    def _on_db_validation_changed(self, is_valid, message):
+        """Handle database validation state changes"""
+        if not is_valid:
+            self.logger.debug(f"Database validation failed: {message}")
+            # Only show dialog if we're not in startup tab
+            startup_tab = self.find_tab_by_title("Startup")
+            if startup_tab and self.view.tab_widget.currentWidget() == startup_tab:
+                return
+            # Switch to startup tab for invalid paths (including when files are deleted)
+            # but keep the current path
+            if not startup_tab:
+                self._open_startup_tab(keep_db_path=True)
+                return
+        else:
+            self._cspr_deletion_dialog_shown = False  # Reset flag
+            if "Successfully changed database directory to:" in message:
+                show_message(
+                    "Database Directory Change Complete",
+                    message,
+                    QtWidgets.QMessageBox.Icon.Information
+                )
+                # Refresh home tab if it exists
+                home_tab = self.find_tab_by_title("Home")
+                if home_tab and home_tab in self.tab_widgets['controllers']:
+                    home_controller = self.tab_widgets['controllers']["Home"]
+                    home_controller.refresh_data()
+    def _on_db_state_changed(self, is_valid, message, changes):
+        """Handle database state changes"""
+        try:
+            self.logger.debug(f"Database state changed - Valid: {is_valid}, Message: {message}, Changes: {changes}")
+            # If path becomes invalid (including when files are deleted), switch to startup tab
+            if not is_valid:
+                # Skip only if we're already in startup tab
+                startup_tab = self.find_tab_by_title("Startup")
+                if startup_tab and self.view.tab_widget.currentWidget() == startup_tab:
+                    return
+                # Skip only if we're in the process of changing directory for new genome
+                if self.settings.db_manager.is_changing_directory:
+                    return
+                # Otherwise, switch to startup tab with current path
+                self._open_startup_tab(keep_db_path=True)
+                return
+            # Handle other state changes
+            if changes:
+                # Refresh home tab if it exists
+                home_tab = self.find_tab_by_title("Home")
+                if home_tab and home_tab in self.tab_widgets['controllers']:
+                    home_controller = self.tab_widgets['controllers']["Home"]
+                    home_controller.refresh_data()
+        except Exception as e:
+            self.logger.error(f"Error handling database state change: {str(e)}")

src/controllers/NCBIWindowController.py CHANGED Viewed

@@ -14,15 +14,28 @@ class NCBIWindowController:
     def __init__(self, settings):
         self.settings = settings
         try:
             self.logger = self.settings.get_logger()
             self.model = NCBIWindowModel(settings)
             self.view = NCBIWindowView(settings)
             # Connect to the initialization complete signal
             self.view.initialization_complete.connect(self.setup_connections)
             self._init_ui()
         except Exception as e:
             show_error(self.settings, "Error initializing NCBIWindowController", str(e))
     def setup_connections(self):
@@ -134,7 +147,7 @@ class NCBIWindowController:
                 self.logger.info(f"Processing ID: {id}")
                 urls = self.model.get_download_url(id, self.view.radio_button_collections_genbank.isChecked())
-                self.logger.info(f"Download URLs for ID {id}: {urls}")
                 if not urls:
                     self.logger.warning(f"No download URL found for ID: {id}")

     def __init__(self, settings):
         self.settings = settings
         try:
+            start_time = time.time()
             self.logger = self.settings.get_logger()
+            self.logger.debug("Starting NCBIWindowController initialization")
+            # Log model initialization time
+            model_start = time.time()
             self.model = NCBIWindowModel(settings)
+            self.logger.debug(f"Model initialization took: {time.time() - model_start:.2f} seconds")
+            # Log view initialization time
+            view_start = time.time()
             self.view = NCBIWindowView(settings)
+            self.logger.debug(f"View initialization took: {time.time() - view_start:.2f} seconds")
             # Connect to the initialization complete signal
             self.view.initialization_complete.connect(self.setup_connections)
             self._init_ui()
+            self.logger.debug(f"Total NCBIWindowController initialization took: {time.time() - start_time:.2f} seconds")
         except Exception as e:
+            self.logger.error(f"Error initializing NCBIWindowController: {str(e)}")
             show_error(self.settings, "Error initializing NCBIWindowController", str(e))
     def setup_connections(self):
                 self.logger.info(f"Processing ID: {id}")
                 urls = self.model.get_download_url(id, self.view.radio_button_collections_genbank.isChecked())
+                self.logger.info(f"Download URLs for ID {id}: {urls} in database")
                 if not urls:
                     self.logger.warning(f"No download URL found for ID: {id}")

src/controllers/NewGenomeWindowController.py CHANGED Viewed

@@ -3,11 +3,13 @@ from models.NewGenomeWindowModel import NewGenomeWindowModel
 from views.NewGenomeWindowView import NewGenomeWindowView
 from utils.ui import show_message, show_error
 import os
 class NewGenomeWindowController:
     def __init__(self, global_settings):
         self.settings = global_settings
         self.logger = global_settings.get_logger()
         try:
             self.model = NewGenomeWindowModel(self.settings)
@@ -66,25 +68,37 @@ class NewGenomeWindowController:
         # self._load_endonuclease_settings()
     def _handle_reset(self):
-        self.view.line_edit_organism_name.clear()
-        self.view.line_edit_strain.clear()
-        self.view.line_edit_organism_code.clear()
-        self.model.file = ""
-        self.view.line_edit_selected_file.clear()
-        self.view.line_edit_selected_file.setPlaceholderText("Selected FASTA/FNA File")
-        self.view.reset_table_widget_jobs()
-        self.view.reset_progress_bar_jobs()
-        # Reinitialize the process
-        if self.job_process.state() != QtCore.QProcess.ProcessState.NotRunning:
-            self.job_process.kill()
-        self._initialize_process()
-        # Reset the model
-        self.model.reset_progress()
-        self.model.jobs.clear()
     def _add_job_to_table(self):
         organism_name = self.view.get_organism_name()
@@ -123,16 +137,28 @@ class NewGenomeWindowController:
     def _browse_fasta_file(self):
         file_dialog = QtWidgets.QFileDialog()
-        database_dir = self.settings.get_db_path()
-        file_path, _ = file_dialog.getOpenFileName(self.view, "Choose a File", database_dir, "FASTA Files (*.fa *.fna *.fasta)")
         if file_path:
             if self.model.validate_fasta_file(file_path):
                 self.model.file = file_path
                 self.view.set_selected_file(file_path)
             else:
-                show_message(fontSize=12, icon=QtWidgets.QMessageBox.Icon.Critical,
-                             title="File Selection Error",
-                             message="You have selected an incorrect type of file. Please choose a FASTA/FNA file.")
     def _remove_selected_job(self):
         job_identifier = self.view.get_selected_job_identifier()
@@ -235,48 +261,73 @@ class NewGenomeWindowController:
         self.view.table_widget_jobs.viewport().update()
     def _handle_job_completion(self, exit_code=None, exit_status=None):
-        self.logger.debug(f"Process finished with exit code: {exit_code}")
-        # Log any remaining output
-        remaining_output = self.job_process.readAllStandardOutput().data().decode()
-        if remaining_output:
-            self.logger.debug(f"Final process output: {remaining_output}")
-        remaining_error = self.job_process.readAllStandardError().data().decode()
-        if remaining_error:
-            self.logger.error(f"Final process error output: {remaining_error}")
-        if hasattr(self, 'job_indexes') and self.job_indexes:
-            completed_row_index = self.job_indexes.pop(0)
-            # Check if output files were created
-            expected_cspr_file = os.path.join(self.settings.get_db_path(), f"{self.model.get_job_name(completed_row_index)}.cspr")
-            if os.path.exists(expected_cspr_file):
-                self.logger.debug(f"CSPR file created successfully: {expected_cspr_file}")
-            else:
-                self.logger.error(f"Expected CSPR file not found: {expected_cspr_file}")
-            # Set job as completed
-            self.view.set_job_completed(completed_row_index)
-            # Update model's completed jobs count and progress bar
-            total_progress = self.model.increment_completed_jobs()
-            if total_progress is not None:
-                self.view.set_progress_bar_jobs(total_progress)
-            else:
-                self.logger.warning("Received None for total_progress")
-            if self.job_indexes:
-                next_row_index = self.job_indexes[0]
-                self._run_job(next_row_index)
             else:
-                self.logger.info("All queued jobs completed")
-                self.view.set_progress_bar_jobs(100)
-                self.settings.update_db_state()
-        else:
-            self.logger.warning("No job indexes found or all jobs completed")
-        self.view.table_widget_jobs.viewport().update()
     def _reset_table_widget_jobs(self):
         self.view.reset_table_widget_jobs()
@@ -293,10 +344,13 @@ class NewGenomeWindowController:
             # Connect to the initialization complete signal
             def on_init_complete():
                 if organism_name:
                     ncbi_controller.view.line_edit_organism.setText(organism_name)
                 if strain_name:
                     ncbi_controller.view.line_edit_strain.setText(strain_name)
             # Connect the signal
             ncbi_controller.view.initialization_complete.connect(on_init_complete)
@@ -308,9 +362,6 @@ class NewGenomeWindowController:
             show_error(self.settings, "Error opening NCBI module", str(e))
             self.logger.error(f"Failed to open NCBI module: {str(e)}")
-    # def _on_cspr_files_created(self):
-        # self.settings.update_db_state()
     def _load_initial_endonuclease_settings(self):
         initial_endonuclease = self.view.get_selected_endonuclease()
         print(f"Initial endonuclease: {initial_endonuclease}")

 from views.NewGenomeWindowView import NewGenomeWindowView
 from utils.ui import show_message, show_error
 import os
+from PyQt6.QtCore import pyqtSignal
 class NewGenomeWindowController:
     def __init__(self, global_settings):
         self.settings = global_settings
         self.logger = global_settings.get_logger()
+        self.directory_change_completed = pyqtSignal(str)
         try:
             self.model = NewGenomeWindowModel(self.settings)
         # self._load_endonuclease_settings()
     def _handle_reset(self):
+        try:
+            self.view.line_edit_organism_name.clear()
+            self.view.line_edit_strain.clear()
+            self.view.line_edit_organism_code.clear()
+            self.model.file = ""
+            self.view.line_edit_selected_file.clear()
+            self.view.line_edit_selected_file.setPlaceholderText("Selected FASTA/FNA File")
+            self.view.reset_table_widget_jobs()
+            self.view.reset_progress_bar_jobs()
+            # Reinitialize the process
+            if self.job_process.state() != QtCore.QProcess.ProcessState.NotRunning:
+                self.job_process.kill()
+            self._initialize_process()
+            # Reset the model
+            self.model.reset_progress()
+            self.model.jobs.clear()
+            # Cancel any pending database path change
+            self.settings.db_manager.pending_db_path = None
+            self.logger.debug("Cancelled pending database path change")
+            # Show confirmation to user
+            show_message("Reset Complete",
+                        "Form has been reset and any pending database changes have been cancelled.")
+        except Exception as e:
+            self.logger.error(f"Error in handle reset: {str(e)}")
+            show_error(self.settings, "Error", str(e))
     def _add_job_to_table(self):
         organism_name = self.view.get_organism_name()
     def _browse_fasta_file(self):
         file_dialog = QtWidgets.QFileDialog()
+        database_dir = self.settings.db_manager.get_active_db_path()
+        self.logger.debug(f"Opening file dialog with directory: {database_dir}")
+        file_path, _ = file_dialog.getOpenFileName(
+            self.view,
+            "Choose a File",
+            database_dir,
+            "FASTA Files (*.fa *.fna *.fasta)"
+        )
         if file_path:
             if self.model.validate_fasta_file(file_path):
                 self.model.file = file_path
                 self.view.set_selected_file(file_path)
+                self.logger.debug(f"Selected valid FASTA file: {file_path}")
             else:
+                show_message(
+                    fontSize=12,
+                    icon=QtWidgets.QMessageBox.Icon.Critical,
+                    title="File Selection Error",
+                    message="You have selected an incorrect type of file. Please choose a FASTA/FNA file."
+                )
     def _remove_selected_job(self):
         job_identifier = self.view.get_selected_job_identifier()
         self.view.table_widget_jobs.viewport().update()
     def _handle_job_completion(self, exit_code=None, exit_status=None):
+        """Handle process completion and job status updates"""
+        try:
+            self.logger.debug(f"Process finished with exit code: {exit_code}")
+            # Log any remaining output
+            remaining_output = self.job_process.readAllStandardOutput().data().decode()
+            if remaining_output:
+                self.logger.debug(f"Final process output: {remaining_output}")
+            remaining_error = self.job_process.readAllStandardError().data().decode()
+            if remaining_error:
+                self.logger.error(f"Final process error output: {remaining_error}")
+            if hasattr(self, 'job_indexes') and self.job_indexes:
+                completed_row_index = self.job_indexes.pop(0)
+                # Get the job name for the completed job
+                job_name = self.model.get_job_name(completed_row_index)
+                expected_cspr_file = os.path.join(self.settings.get_db_path(), f"{job_name}.cspr")
+                if exit_code == 0 and os.path.exists(expected_cspr_file):
+                    self.logger.debug(f"CSPR file created successfully: {expected_cspr_file}")
+                    self.view.set_job_completed(completed_row_index)
+                    # Update model's completed jobs count and progress bar
+                    total_progress = self.model.increment_completed_jobs()
+                    if total_progress is not None:
+                        self.view.set_progress_bar_jobs(total_progress)
+                    else:
+                        self.logger.warning("Received None for total_progress")
+                    # If we're in directory change mode, trigger a database state update
+                    if self.settings.db_manager.is_changing_directory:
+                        self.logger.debug("Directory change in progress - triggering state update")
+                        self.settings.db_manager.update_db_state()
+                else:
+                    error_msg = f"Job failed: CSPR file not found or process error (exit code: {exit_code})"
+                    self.logger.error(error_msg)
+                    show_error(self.settings, f"Job Failed: {job_name}", error_msg)
+                # Process next job if any
+                if self.job_indexes:
+                    next_row_index = self.job_indexes[0]
+                    self._run_job(next_row_index)
+                else:
+                    self.logger.info("All queued jobs completed")
+                    self.view.set_progress_bar_jobs(100)
+                    # If we were changing directory, finalize the change
+                    if self.settings.db_manager.is_changing_directory:
+                        self.logger.debug("Finalizing directory change after successful genome analysis")
+                        success, message = self.settings.db_manager.finalize_directory_change()
+                        if success:
+                            self.directory_change_completed.emit(message)
+                        else:
+                            self.logger.error(f"Failed to finalize directory change: {message}")
+                    else:
+                        # Just update the state if not changing directory
+                        self.settings.update_db_state()
             else:
+                self.logger.warning("No job indexes found or all jobs completed")
+            self.view.table_widget_jobs.viewport().update()
+        except Exception as e:
+            self.logger.error(f"Error in _handle_job_completion: {str(e)}")
     def _reset_table_widget_jobs(self):
         self.view.reset_table_widget_jobs()
             # Connect to the initialization complete signal
             def on_init_complete():
+                self.logger.debug(f"NCBI window initialized, setting organism: {organism_name}, strain: {strain_name}")
                 if organism_name:
                     ncbi_controller.view.line_edit_organism.setText(organism_name)
                 if strain_name:
                     ncbi_controller.view.line_edit_strain.setText(strain_name)
+                # Disconnect after use to prevent multiple connections
+                ncbi_controller.view.initialization_complete.disconnect(on_init_complete)
             # Connect the signal
             ncbi_controller.view.initialization_complete.connect(on_init_complete)
             show_error(self.settings, "Error opening NCBI module", str(e))
             self.logger.error(f"Failed to open NCBI module: {str(e)}")
     def _load_initial_endonuclease_settings(self):
         initial_endonuclease = self.view.get_selected_endonuclease()
         print(f"Initial endonuclease: {initial_endonuclease}")

src/controllers/OffTargetController.py CHANGED Viewed

@@ -218,6 +218,18 @@ class OffTargetController(QObject):
                 if endo_index >= 0:
                     self.view.combo_box_endonuclease.setCurrentIndex(endo_index)
             # Store targets for analysis
             if 'guides' in parameters:
                 self._targets = parameters['guides']

                 if endo_index >= 0:
                     self.view.combo_box_endonuclease.setCurrentIndex(endo_index)
+            # Validate and set annotation file
+            if 'annotation_file' not in parameters:
+                raise ValueError("No annotation file provided in parameters")
+            annotation_file = parameters['annotation_file']
+            if not annotation_file:
+                raise ValueError("Empty annotation file path provided")
+            # Set annotation file in global settings
+            self.global_settings.set_current_annotation_file(annotation_file)
+            self.logger.debug(f"Set annotation file to: {annotation_file}")
             # Store targets for analysis
             if 'guides' in parameters:
                 self._targets = parameters['guides']

src/controllers/PopulationAnalysisWindowController.py CHANGED Viewed

@@ -39,7 +39,6 @@ class PopulationAnalysisWindowController:
     def launch(self):
         try:
             self.logger = self.global_settings.get_logger()
-            self.logger.info("Launching Population Analysis Window")
             self.get_data()
         except Exception as e:
             self.logger.error(f"Error in launch(): {str(e)}")
@@ -47,7 +46,6 @@ class PopulationAnalysisWindowController:
     def get_data(self):
         try:
-            self.logger.info("Getting data for Population Analysis")
             self.fillEndo()
         except Exception as e:
             self.logger.error(f"Error in get_data(): {str(e)}")
@@ -55,7 +53,6 @@ class PopulationAnalysisWindowController:
     def fillEndo(self):
         try:
-            self.logger.info("Starting fillEndo()")
             endos = self.model.load_endonucleases()
             self.logger.debug(f"Loaded endonucleases: {endos}")
@@ -64,7 +61,6 @@ class PopulationAnalysisWindowController:
                 show_error(self.global_settings, "Error", "No endonucleases found")
                 return
-            self.logger.info(f"Updating dropdown with {len(endos)} endonucleases")
             self.view.update_endo_dropdown(endos.keys())
             self.change_endo()
         except Exception as e:
@@ -190,8 +186,6 @@ class PopulationAnalysisWindowController:
                 data['pams'][majority_index],    # PAM
                 strand                 # Strand
             )
-            self.logger.debug(f"Processed seed data: {row_data}")
             return row_data
         except Exception as e:

     def launch(self):
         try:
             self.logger = self.global_settings.get_logger()
             self.get_data()
         except Exception as e:
             self.logger.error(f"Error in launch(): {str(e)}")
     def get_data(self):
         try:
             self.fillEndo()
         except Exception as e:
             self.logger.error(f"Error in get_data(): {str(e)}")
     def fillEndo(self):
         try:
             endos = self.model.load_endonucleases()
             self.logger.debug(f"Loaded endonucleases: {endos}")
                 show_error(self.global_settings, "Error", "No endonucleases found")
                 return
             self.view.update_endo_dropdown(endos.keys())
             self.change_endo()
         except Exception as e:
                 data['pams'][majority_index],    # PAM
                 strand                 # Strand
             )
             return row_data
         except Exception as e:

src/controllers/StartupWindowController.py CHANGED Viewed

@@ -6,10 +6,11 @@ from views.StartupWindowView import StartupWindowView
 import sys
 class StartupWindowController:
-    def __init__(self, global_settings):
         self.settings = global_settings
         self.logger = self.settings.get_logger()
-        self.is_active = True  # Initialize is_active here
         try:
             self.view = StartupWindowView(self.settings)
@@ -31,10 +32,19 @@ class StartupWindowController:
         self.view.db_path_text_changed.connect(self._on_db_path_text_changed)
         self.model.db_state_updated.connect(self._on_db_state_updated)
         self.settings.db_manager.db_validation_changed.connect(self._on_db_validation_changed)
         self.view.open_new_genome_requested.connect(self.open_new_genome_tab)
     def _on_db_path_text_changed(self, new_path):
-        self.model.save_db_path(new_path)
     def _on_db_state_updated(self, is_valid, message, cspr_files):
         if self.is_active and hasattr(self, 'view'):
@@ -45,15 +55,63 @@ class StartupWindowController:
         if self.is_active and hasattr(self, 'view'):
             self.view.set_db_status(is_valid, message)
     def _init_ui(self):
-        db_path = self.model.get_db_path()
-        self.logger.debug(f"Initial database path: {db_path}")
-        self._init_db_state(db_path)
     def _init_db_state(self, db_path):
-        self.view.set_db_path(db_path)
-        is_valid, message = self.settings.validate_db_path(db_path)
-        self.view.set_db_status(is_valid, message)
     def _set_database_directory(self):
         try:

 import sys
 class StartupWindowController:
+    def __init__(self, global_settings, keep_db_path=False):
         self.settings = global_settings
         self.logger = self.settings.get_logger()
+        self.is_active = True
+        self.keep_db_path = keep_db_path
         try:
             self.view = StartupWindowView(self.settings)
         self.view.db_path_text_changed.connect(self._on_db_path_text_changed)
         self.model.db_state_updated.connect(self._on_db_state_updated)
         self.settings.db_manager.db_validation_changed.connect(self._on_db_validation_changed)
+        self.settings.db_manager.db_files_changed.connect(self._on_db_files_changed)
         self.view.open_new_genome_requested.connect(self.open_new_genome_tab)
     def _on_db_path_text_changed(self, new_path):
+        """Handle database path text changes"""
+        try:
+            # Avoid triggering save if the path hasn't actually changed
+            if new_path == self.model.get_db_path():
+                return
+            self.model.save_db_path(new_path)
+        except Exception as e:
+            self.logger.error(f"Error handling db path change: {str(e)}")
     def _on_db_state_updated(self, is_valid, message, cspr_files):
         if self.is_active and hasattr(self, 'view'):
         if self.is_active and hasattr(self, 'view'):
             self.view.set_db_status(is_valid, message)
+    def _on_db_files_changed(self, changes):
+        """Handle database file changes"""
+        if self.is_active and hasattr(self, 'view'):
+            # Re-validate the current path
+            db_path = self.model.get_db_path()
+            is_valid, message = self.settings.validate_db_path(db_path)
+            self.view.set_db_status(is_valid, message)
+            # If path is now valid and we have CSPR files, update button text
+            if is_valid:
+                self.view.push_button_go_to_home_or_new_genome.setText("Go to Home")
     def _init_ui(self):
+        """Initialize the UI with the correct database path"""
+        try:
+            # Always get the current path from settings
+            db_path = self.model.get_db_path()
+            # For true first time startup (no previous path), show default path
+            if self.settings.is_first_time_startup and not db_path:
+                db_path = self.settings.db_manager.get_default_database_path()
+            # For invalid path case, keep the existing path
+            elif not self.keep_db_path and not self.settings.is_first_time_startup:
+                db_path = ''
+            self.logger.debug(f"Initial database path: {db_path}, keep_db_path: {self.keep_db_path}, "
+                             f"first_time_startup: {self.settings.is_first_time_startup}")
+            # Set the path in the view first
+            self.view.set_db_path(db_path)
+            # Then initialize the state
+            if db_path:
+                is_valid, message = self.settings.validate_db_path(db_path)
+                self.view.set_db_status(is_valid, message)
+            else:
+                self.view.set_db_status(False, "No directory selected")
+        except Exception as e:
+            self.logger.error(f"Error in _init_ui: {str(e)}")
+            raise
     def _init_db_state(self, db_path):
+        """Initialize database state"""
+        try:
+            # Only update the view's path if it's different from current
+            current_view_path = self.view.get_db_path()
+            if current_view_path != db_path:
+                self.view.set_db_path(db_path)
+            # Validate and update status
+            is_valid, message = self.settings.validate_db_path(db_path)
+            self.view.set_db_status(is_valid, message)
+        except Exception as e:
+            self.logger.error(f"Error in _init_db_state: {str(e)}")
+            raise
     def _set_database_directory(self):
         try:

src/controllers/ViewTargetsController.py CHANGED Viewed

@@ -8,6 +8,7 @@ import traceback
 from views.LoadingDialog import LoadingDialog
 from PyQt6.QtWidgets import QApplication
 from PyQt6.QtGui import QColor
 class ViewTargetsController:
     def __init__(self, global_settings):
@@ -31,7 +32,6 @@ class ViewTargetsController:
         self.view.push_button_change_location.clicked.connect(self.change_indices)
         self.view.push_button_reset_location.clicked.connect(self.reset_location)
         self.view.check_box_select_all.stateChanged.connect(self.select_all)
-        # self.view.combo_box_gene.currentIndexChanged.connect(self.display_gene_data)
         self.view.gene_selected.connect(self.on_gene_selected)
         self.view.check_box_filter_5_prime_g_sequences.stateChanged.connect(self.refresh_guides_display)
@@ -42,12 +42,34 @@ class ViewTargetsController:
         """Handle view exons only checkbox state change"""
         try:
             is_checked = self.view.check_box_view_exons_only.isChecked()
-            self.logger.debug(f"View exons only changed to: {is_checked}")
             self.model.set_view_exons_only(is_checked)
             self.refresh_gene_viewer()
         except Exception as e:
             self.logger.error(f"Error handling view exons change: {str(e)}")
     def load_guides(self, selected_targets, organism, endonuclease, loading_dialog=None):
         try:
             self.organism = organism
@@ -62,6 +84,9 @@ class ViewTargetsController:
                 QApplication.processEvents()
             try:
                 loading_dialog.set_message("Loading guides...", 60)
                 QApplication.processEvents()
@@ -92,43 +117,73 @@ class ViewTargetsController:
                 loading_dialog.set_message("Updating display...", 80)
                 QApplication.processEvents()
-                self.view.display_guides_in_table(guides)
-                # Only trigger gene selection if this is the initial load
-                if not hasattr(self, '_initial_load_complete'):
-                    loading_dialog.set_message("Loading initial gene data...", 90)
-                    QApplication.processEvents()
-                    # Get unique position names or gene IDs
-                    unique_entries = set()
-                    for target in selected_targets:
-                        if 'feature_id' in target:
-                            # For position-based searches, use the feature_id directly
-                            if "chromosome" in str(target['feature_id']):
-                                unique_entries.add(target['feature_id'])
-                            else:
-                                # For gene-based searches, get gene data and format with name
-                                locus_tag = target['feature_id']
-                                gene_data = self.model.get_gene_data(locus_tag)
-                                if gene_data and 'info' in gene_data:
-                                    gene_name = gene_data['info'].get('gene_name', '')
-                                    display_text = f"{locus_tag}: {gene_name}" if gene_name else locus_tag
-                                    unique_entries.add(display_text)
-                    # Convert set to list for combo box
-                    entries = list(unique_entries)
-                    self.logger.debug(f"Found {len(entries)} unique entries")
                     self.view.set_combo_box_gene(entries)
-                    # Set first entry without triggering the selection signal
-                    if entries:
-                        self.view.combo_box_gene.blockSignals(True)
-                        self.view.combo_box_gene.setCurrentIndex(0)
-                        self.view.combo_box_gene.blockSignals(False)
-                        self._load_initial_gene_data(entries[0])
-                    self._initial_load_complete = True
                 loading_dialog.set_progress(100)
                 QApplication.processEvents()
@@ -144,53 +199,6 @@ class ViewTargetsController:
             self.logger.error(f"Stack trace: {traceback.format_exc()}")
             show_error(self.settings, "Error loading guides", str(e))
-    def _load_initial_gene_data(self, selected_text):
-        """Load initial gene data without showing loading dialog"""
-        try:
-            # Similar to on_gene_selected but without loading dialog
-            if "chromosome" in selected_text and "start:" in selected_text:
-                # Parse position from the text
-                parts = selected_text.split(',')
-                chrom = parts[0].split('chromosome')[1].strip()  # Remove any extra colons
-                start = int(parts[1].split('start:')[1].strip())
-                end = int(parts[2].split('end:')[1].strip())
-                self.view.line_edit_start_location.setText(str(start))
-                self.view.line_edit_stop_location.setText(str(end))
-                # Get sequence directly for position-based search
-                sequence = self.model._get_sequence_for_position(chrom, start, end)
-                if sequence:
-                    # Update gene viewer with sequence
-                    self.view.update_gene_viewer(sequence, [])
-                    self.logger.debug(f"Updated gene viewer with sequence of length {len(sequence)}")
-                else:
-                    self.logger.error(f"Could not get sequence for position {start}-{end} in chromosome {chrom}")
-                position_guides = [g for g in self.model.guides
-                                 if g.get('feature_id') == selected_text]
-                self.view.display_guides_in_table(position_guides)
-            else:
-                # Regular gene-based search
-                locus_tag = selected_text.split(': ')[0] if ': ' in selected_text else selected_text
-                sequence_data = self.model.get_gene_sequence(locus_tag)
-                if sequence_data:
-                    self.view.line_edit_start_location.setText(str(sequence_data['start']))
-                    self.view.line_edit_stop_location.setText(str(sequence_data['end']))
-                    features = self.model.get_features_for_gene(locus_tag)
-                    self.view.update_gene_viewer(sequence_data['sequence'], features)
-                    gene_guides = [g for g in self.model.guides
-                                  if str(g.get('feature_id', '')).strip().lower() == locus_tag.lower()]
-                    self.view.display_guides_in_table(gene_guides)
-            self.logger.debug("Initial gene data loaded successfully")
-        except Exception as e:
-            self.logger.error(f"Error loading initial gene data: {str(e)}")
     def _on_endonuclease_changed(self, new_endonuclease):
         try:
             if new_endonuclease != self.endonuclease:
@@ -210,8 +218,6 @@ class ViewTargetsController:
                         new_target['endonuclease'] = new_endonuclease
                         updated_targets.append(new_target)
-                    self.logger.debug(f"Created {len(updated_targets)} updated targets for {new_endonuclease}")
                     # Update model with new targets
                     self.model.load_guides(updated_targets, self.organism, new_endonuclease)
                     guides = self.model.get_guides()
@@ -226,36 +232,6 @@ class ViewTargetsController:
             self.logger.error(f"Stack trace: {traceback.format_exc()}")
             show_error(self.settings, "Error", f"Could not change endonuclease: {str(e)}")
-    # def load_gene_viewer(self):
-    #     try:
-    #         # Get selected gene from combo box
-    #         selected_text = self.view.combo_box_gene.currentText()
-    #         if not selected_text:
-    #             self.logger.debug("No gene selected")
-    #             return
-    #         # Extract locus tag from "locus_tag: gene_name" format
-    #         locus_tag = selected_text.split(': ')[0] if ': ' in selected_text else selected_text
-    #         self.logger.debug(f"Loading sequence for locus tag: {locus_tag}")
-    #         # Get gene sequence with padding
-    #         sequence_data = self.model.get_gene_sequence(locus_tag)
-    #         if sequence_data:
-    #             # Update gene viewer with sequence
-    #             self.view.set_text_edit_gene_viewer(sequence_data['sequence'])
-    #             # Update location fields
-    #             self.view.line_edit_start_location.setText(str(sequence_data['start']))
-    #             self.view.line_edit_stop_location.setText(str(sequence_data['end']))
-    #         else:
-    #             self.logger.warning(f"No sequence data found for locus tag {locus_tag}")
-    #     except Exception as e:
-    #         self.logger.error(f"Error in load_gene_viewer: {str(e)}")
-    #         self.logger.error(f"Stack trace: {traceback.format_exc()}")
     def perform_off_target_analysis(self):
         """Launch off-target analysis for selected guides"""
         try:
@@ -279,11 +255,35 @@ class ViewTargetsController:
                     self._handle_off_target_results
                 )
             # Set initial parameters based on current organism/endonuclease
             parameters = {
                 'organism': self.organism,
                 'endonuclease': self.endonuclease,
-                'guides': selected_guides  # Pass the selected guides
             }
             # Initialize analysis with parameters
@@ -473,20 +473,9 @@ class ViewTargetsController:
             show_error(self.settings, "Error", f"Could not show scoring options: {str(e)}")
     def change_indices(self):
-        """Change the start and end positions for gene viewer"""
         try:
-            # Make sure gene viewer has content
-            if not self.view.text_edit_gene_viewer.toPlainText():
-                QMessageBox.warning(
-                    self.view,
-                    "Gene Viewer Error",
-                    "Gene Viewer display is empty! Please ensure there is sequence data to view."
-                )
-                return
-            # Get current gene/position info
-            current_gene = self.view.combo_box_gene.currentText()
             try:
                 new_start = int(self.view.line_edit_start_location.text())
                 new_end = int(self.view.line_edit_stop_location.text())
@@ -523,7 +512,10 @@ class ViewTargetsController:
                 )
                 return
-            # Get sequence for new range
             if "chromosome" in current_gene and "start:" in current_gene:
                 # For position-based searches
                 try:
@@ -531,12 +523,14 @@ class ViewTargetsController:
                     # Get full chromosome identifier instead of just the number
                     chrom = parts[0].split('chromosome')[1].strip()  # This will now keep the full identifier
-                    # Get sequence for new range
-                    sequence = self.model._get_sequence_for_position(chrom, new_start, new_end)
                     if sequence:
-                        self.view.set_text_edit_gene_viewer(sequence)
-                        # Update the line edits with new positions
                         self.view.line_edit_start_location.setText(str(new_start))
                         self.view.line_edit_stop_location.setText(str(new_end))
                     else:
@@ -545,44 +539,60 @@ class ViewTargetsController:
                 except Exception as e:
                     QMessageBox.warning(
                         self.view,
-                        "Position Error",
-                        f"Error changing position: {str(e)}"
                     )
-                    return
             else:
-                # For feature-based searches
                 locus_tag = current_gene.split(': ')[0] if ': ' in current_gene else current_gene
-                gene_data = self.model.get_gene_data(locus_tag)
-                if not gene_data or 'info' not in gene_data:
-                    QMessageBox.warning(
-                        self.view,
-                        "Gene Data Error",
-                        "Could not get gene data for the current selection."
-                    )
-                    return
-                print(f"locus_tag: {locus_tag}, new_start: {new_start}, new_end: {new_end}")
-                # Get new sequence for the range
-                sequence_data = self.model.get_gene_sequence_for_range(locus_tag, new_start, new_end)
-                if sequence_data:
-                    self.view.set_text_edit_gene_viewer(sequence_data['sequence'])
-                    # Update the line edits with new positions
-                    self.view.line_edit_start_location.setText(str(new_start))
-                    self.view.line_edit_stop_location.setText(str(new_end))
                 else:
                     QMessageBox.warning(
                         self.view,
-                        "Sequence Error",
-                        "Could not get sequence for the specified range."
                     )
-                    return
         except Exception as e:
-            self.logger.error(f"Error in change_indices: {str(e)}")
             self.logger.error(f"Stack trace: {traceback.format_exc()}")
-            show_error(self.settings, "Error changing indices", str(e))
     def reset_location(self):
         """Reset gene viewer to the original sequence and location"""
@@ -602,12 +612,17 @@ class ViewTargetsController:
                     # Get sequence directly using model's method
                     sequence = self.model._get_sequence_for_position(chrom, start, end)
                     if sequence:
-                        # Update gene viewer with sequence
-                        self.view.set_text_edit_gene_viewer(sequence)
-                        # Update location fields - subtract 1 from start to match 0-based indexing
                         self.view.line_edit_start_location.setText(str(start + 1))
                         self.view.line_edit_stop_location.setText(str(end))
                     else:
                         raise ValueError("Could not get sequence for position")
@@ -620,30 +635,41 @@ class ViewTargetsController:
                     )
                     return
             else:
-                # For feature-based searches
                 locus_tag = current_gene.split(': ')[0] if ': ' in current_gene else current_gene
-                sequence_data = self.model.get_gene_sequence(locus_tag)
                 if sequence_data:
-                    # Update gene viewer with sequence
-                    self.view.set_text_edit_gene_viewer(sequence_data['sequence'])
-                    # Update location fields - subtract 1 from start to match 0-based indexing
                     self.view.line_edit_start_location.setText(str(sequence_data['start'] + 1))
                     self.view.line_edit_stop_location.setText(str(sequence_data['end']))
                 else:
-                    self.logger.warning(f"No sequence data found for locus tag {locus_tag}")
                     QMessageBox.warning(
                         self.view,
-                        "Gene Data Error",
-                        "Could not get gene sequence for resetting location."
                     )
-                    return
         except Exception as e:
             self.logger.error(f"Error in reset_location: {str(e)}")
             self.logger.error(f"Stack trace: {traceback.format_exc()}")
-            show_error(self.settings, "Error resetting location", str(e))
     def select_all(self, state):
         try:
@@ -673,6 +699,10 @@ class ViewTargetsController:
                 # Get current guides from model
                 self.model.load_guides(self.selected_targets, self.organism, self.endonuclease)
                 guides = self.model.get_guides()
                 self.view.display_guides_in_table(guides)
         except Exception as e:
             show_error(self.settings, "Error refreshing guides display", str(e))
@@ -689,6 +719,9 @@ class ViewTargetsController:
             QApplication.processEvents()
             try:
                 # Load data in chunks
                 loading_dialog.set_message("Loading sequence data...", 30)
                 QApplication.processEvents()
@@ -704,33 +737,41 @@ class ViewTargetsController:
                     self.view.line_edit_start_location.setText(str(start))
                     self.view.line_edit_stop_location.setText(str(end))
-                    # Filter guides efficiently
-                    loading_dialog.set_message("Filtering guides...", 60)
-                    QApplication.processEvents()
-                    position_guides = [g for g in self.model.guides
-                                     if g.get('feature_id') == selected_text]
                     self.view.display_guides_in_table(position_guides)
                 else:
-                    # Regular gene-based search with optimized loading
                     locus_tag = selected_text.split(': ')[0] if ': ' in selected_text else selected_text
-                    sequence_data = self.model.get_gene_sequence(locus_tag)
-                    if sequence_data:
-                        self.view.line_edit_start_location.setText(str(sequence_data['start']))
-                        self.view.line_edit_stop_location.setText(str(sequence_data['end']))
                         loading_dialog.set_message("Updating display...", 80)
                         QApplication.processEvents()
                         gene_guides = [g for g in self.model.guides
-                                      if str(g.get('feature_id', '')).strip().lower() == locus_tag.lower()]
                         self.view.display_guides_in_table(gene_guides)
-                # Refresh gene viewer
-                loading_dialog.set_message("Refreshing viewer...", 90)
-                QApplication.processEvents()
-                self.refresh_gene_viewer()
             finally:
                 loading_dialog.close()
@@ -781,19 +822,22 @@ class ViewTargetsController:
                         print("Negative strand")
                         # Convert sequence to complement for negative strand search
                         print(f"Sequence: {sequence_upper}")
-                        complement_sequence = ''.join({'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G', 'K': 'M', 'Y': 'R', 'R': 'Y', 'M': 'K', 'S': 'S'}[base] for base in sequence_upper)
                         print(f"Complement sequence: {complement_sequence}")
                         target_sequence = guide_sequence.upper()
                         print(f"Target sequence: {target_sequence}")
-                        target_sequence = target_sequence[::-1]
                         print(f"Reversed target sequence: {target_sequence}")
                         pos = complement_sequence.find(target_sequence)
                         print(f"Position: {pos}")
                         if pos != -1:
                             color = QColor(255, 0, 0, 100)  # Red for negative strand
                             self.logger.debug(f"Found negative strand sequence at position {pos}")
-                            # Pass the original position but indicate negative strand
                             self.view.dna_feature_viewer.sequence_viewer.highlight_sequence(
                                 pos,
                                 pos + len(guide_sequence) - 1,
@@ -1079,12 +1123,25 @@ class ViewTargetsController:
                 chrom = parts[0].split('chromosome')[1].strip()
                 start = int(parts[1].split('start:')[1].strip())
                 end = int(parts[2].split('end:')[1].strip())
                 sequence = self.model._get_sequence_for_position(chrom, start, end)
                 if sequence:
                     # Get features for this region
                     features = self.model.get_features_for_region(chrom, start, end)
-                    self.view.update_gene_viewer(sequence, features)
             else:
                 # Regular gene-based search
                 locus_tag = current_gene.split(': ')[0] if ': ' in current_gene else current_gene
@@ -1094,8 +1151,22 @@ class ViewTargetsController:
                 if sequence_data and 'sequence' in sequence_data:
                     # Get features for this gene
                     features = self.model.get_features_for_gene(locus_tag)
-                    self.view.update_gene_viewer(sequence_data['sequence'], features)
-                    self.logger.debug(f"Updated gene viewer with sequence and {len(features)} features")
                 else:
                     self.logger.warning("No sequence data available")

 from views.LoadingDialog import LoadingDialog
 from PyQt6.QtWidgets import QApplication
 from PyQt6.QtGui import QColor
+import os
 class ViewTargetsController:
     def __init__(self, global_settings):
         self.view.push_button_change_location.clicked.connect(self.change_indices)
         self.view.push_button_reset_location.clicked.connect(self.reset_location)
         self.view.check_box_select_all.stateChanged.connect(self.select_all)
         self.view.gene_selected.connect(self.on_gene_selected)
         self.view.check_box_filter_5_prime_g_sequences.stateChanged.connect(self.refresh_guides_display)
         """Handle view exons only checkbox state change"""
         try:
             is_checked = self.view.check_box_view_exons_only.isChecked()
             self.model.set_view_exons_only(is_checked)
             self.refresh_gene_viewer()
         except Exception as e:
             self.logger.error(f"Error handling view exons change: {str(e)}")
+    def _clear_viewer_state(self):
+        """Clear all highlights and cursor states from the gene viewer"""
+        try:
+            if hasattr(self.view, 'dna_feature_viewer'):
+                # Clear sequence viewer highlights and cursor
+                self.view.dna_feature_viewer.sequence_viewer.clear_highlights()
+                for nuc in self.view.dna_feature_viewer.sequence_viewer.nucleotides:
+                    nuc.show_cursor = False
+                    nuc.update()
+                self.view.dna_feature_viewer.sequence_viewer.selection_active = False
+                self.view.dna_feature_viewer.sequence_viewer.selection_start = None
+                self.view.dna_feature_viewer.sequence_viewer.selection_end = None
+                # Clear insertion zone cursor
+                if hasattr(self.view.dna_feature_viewer, 'insertion_zone'):
+                    if hasattr(self.view.dna_feature_viewer.insertion_zone, 'sequence_cursor'):
+                        self.view.dna_feature_viewer.insertion_zone.sequence_cursor.hide()
+                    self.view.dna_feature_viewer.insertion_zone.current_cursor_pos = None
+                    self.view.dna_feature_viewer.insertion_zone.selection_start = None
+                    self.view.dna_feature_viewer.insertion_zone.selection_end = None
+        except Exception as e:
+            self.logger.error(f"Error clearing viewer state: {str(e)}")
     def load_guides(self, selected_targets, organism, endonuclease, loading_dialog=None):
         try:
             self.organism = organism
                 QApplication.processEvents()
             try:
+                # Clear any existing highlights and cursor
+                self._clear_viewer_state()
                 loading_dialog.set_message("Loading guides...", 60)
                 QApplication.processEvents()
                 loading_dialog.set_message("Updating display...", 80)
                 QApplication.processEvents()
+                # Get unique position names or gene IDs
+                unique_entries = set()
+                for target in selected_targets:
+                    if 'feature_id' in target:
+                        if "chromosome" in str(target['feature_id']):
+                            unique_entries.add(target['feature_id'])
+                        else:
+                            locus_tag = target['feature_id']
+                            gene_data = self.model.get_gene_data(locus_tag)
+                            if gene_data and 'info' in gene_data:
+                                gene_name = gene_data['info'].get('gene_name', '')
+                                display_text = f"{locus_tag}: {gene_name}" if gene_name else locus_tag
+                                unique_entries.add(display_text)
+                # Convert set to list for combo box
+                entries = list(unique_entries)
+                self.logger.debug(f"Found {len(entries)} unique entries")
+                if entries:
+                    first_entry = entries[0]
+                    # Block signals during setup
+                    self.view.combo_box_gene.blockSignals(True)
+                    # Update combo box
                     self.view.set_combo_box_gene(entries)
+                    self.view.combo_box_gene.setCurrentIndex(0)
+                    # Display guides for the first entry
+                    if "chromosome" in first_entry and "start:" in first_entry:
+                        position_guides = [g for g in guides if g.get('feature_id') == first_entry]
+                        self.view.display_guides_in_table(position_guides)
+                        # Parse position from the text
+                        parts = first_entry.split(',')
+                        chrom = parts[0].split('chromosome')[1].strip()
+                        start = int(parts[1].split('start:')[1].strip())
+                        end = int(parts[2].split('end:')[1].strip())
+                        # Update location fields - add 1 to start for display
+                        self.view.line_edit_start_location.setText(str(start + 1))
+                        self.view.line_edit_stop_location.setText(str(end))
+                        # Get sequence directly for position-based search
+                        sequence = self.model._get_sequence_for_position(chrom, start, end)
+                        if sequence:
+                            # Single call to set_data
+                            self.view.dna_feature_viewer.set_data(sequence, [], start)
+                    else:
+                        # Regular gene-based search
+                        locus_tag = first_entry.split(': ')[0] if ': ' in first_entry else first_entry
+                        gene_guides = [g for g in guides if str(g.get('feature_id', '')).strip().lower() == locus_tag.lower()]
+                        self.view.display_guides_in_table(gene_guides)
+                        # Get sequence data and features
+                        sequence_data = self.model.get_gene_sequence(locus_tag)
+                        if sequence_data:
+                            # Update location fields - add 1 to start for display
+                            self.view.line_edit_start_location.setText(str(sequence_data['start'] + 1))
+                            self.view.line_edit_stop_location.setText(str(sequence_data['end']))
+                            # Get features and update viewer in a single call
+                            features = self.model.get_features_for_gene(locus_tag)
+                            self.view.dna_feature_viewer.set_data(sequence_data['sequence'], features, sequence_data['start'])
+                    # Now unblock signals after everything is set up
+                    self.view.combo_box_gene.blockSignals(False)
                 loading_dialog.set_progress(100)
                 QApplication.processEvents()
             self.logger.error(f"Stack trace: {traceback.format_exc()}")
             show_error(self.settings, "Error loading guides", str(e))
     def _on_endonuclease_changed(self, new_endonuclease):
         try:
             if new_endonuclease != self.endonuclease:
                         new_target['endonuclease'] = new_endonuclease
                         updated_targets.append(new_target)
                     # Update model with new targets
                     self.model.load_guides(updated_targets, self.organism, new_endonuclease)
                     guides = self.model.get_guides()
             self.logger.error(f"Stack trace: {traceback.format_exc()}")
             show_error(self.settings, "Error", f"Could not change endonuclease: {str(e)}")
     def perform_off_target_analysis(self):
         """Launch off-target analysis for selected guides"""
         try:
                     self._handle_off_target_results
                 )
+            # Get current annotation file
+            current_annotation_file = self.settings.get_current_annotation_file()
+            if not current_annotation_file:
+                QtWidgets.QMessageBox.warning(
+                    self.view,
+                    "No Annotation File",
+                    "Please select an annotation file before performing off-target analysis."
+                )
+                return
+            # Verify annotation file exists
+            annotation_path = os.path.join(self.settings.get_db_path(), 'GBFF', current_annotation_file)
+            if not os.path.isfile(annotation_path):
+                # Try without GBFF subdirectory
+                annotation_path = os.path.join(self.settings.get_db_path(), current_annotation_file)
+                if not os.path.isfile(annotation_path):
+                    QtWidgets.QMessageBox.warning(
+                        self.view,
+                        "Invalid Annotation File",
+                        f"Could not find annotation file at {annotation_path}"
+                    )
+                    return
             # Set initial parameters based on current organism/endonuclease
             parameters = {
                 'organism': self.organism,
                 'endonuclease': self.endonuclease,
+                'guides': selected_guides,  # Pass the selected guides
+                'annotation_file': current_annotation_file  # Add annotation file
             }
             # Initialize analysis with parameters
             show_error(self.settings, "Error", f"Could not show scoring options: {str(e)}")
     def change_indices(self):
+        """Change the displayed sequence range"""
         try:
+            # Get new start and end positions
             try:
                 new_start = int(self.view.line_edit_start_location.text())
                 new_end = int(self.view.line_edit_stop_location.text())
                 )
                 return
+            # Get current gene/position
+            current_gene = self.view.combo_box_gene.currentText()
+            # Handle position-based search
             if "chromosome" in current_gene and "start:" in current_gene:
                 # For position-based searches
                 try:
                     # Get full chromosome identifier instead of just the number
                     chrom = parts[0].split('chromosome')[1].strip()  # This will now keep the full identifier
+                    # Get sequence for new range - subtract 1 from start for 0-based indexing
+                    sequence = self.model._get_sequence_for_position(chrom, new_start - 1, new_end)
                     if sequence:
+                        # Update DNA viewer with sequence
+                        self.view.dna_feature_viewer.set_data(sequence, [], new_start - 1)
+                        # Update the line edits with new positions (keep display as 1-based)
                         self.view.line_edit_start_location.setText(str(new_start))
                         self.view.line_edit_stop_location.setText(str(new_end))
                     else:
                 except Exception as e:
                     QMessageBox.warning(
                         self.view,
+                        "Sequence Error",
+                        f"Could not get sequence for range {new_start}-{new_end} in chromosome {chrom}"
                     )
             else:
+                # For gene-based searches
                 locus_tag = current_gene.split(': ')[0] if ': ' in current_gene else current_gene
+                # Get gene data to get chromosome information
+                gene_data = self.model.get_gene_data(locus_tag)
+                if gene_data and 'info' in gene_data:
+                    try:
+                        # Get chromosome from gene data
+                        chrom = gene_data['info']['chromosome']
+                        # Get sequence directly using _get_sequence_for_position
+                        sequence = self.model._get_sequence_for_position(chrom, new_start - 1, new_end)
+                        if sequence:
+                            # Update line edits (keep display as 1-based)
+                            self.view.line_edit_start_location.setText(str(new_start))
+                            self.view.line_edit_stop_location.setText(str(new_end))
+                            # Get features for this gene
+                            features = self.model.get_features_for_gene(locus_tag)
+                            # Update DNA viewer with new sequence
+                            self.view.dna_feature_viewer.set_data(sequence, features, new_start - 1)
+                            # Update guides display for new range
+                            gene_guides = [g for g in self.model.guides
+                                         if str(g.get('feature_id', '')).strip().lower() == locus_tag.lower() and
+                                         new_start <= int(g['location'].split('-')[0]) <= new_end]
+                            self.view.display_guides_in_table(gene_guides)
+                        else:
+                            raise ValueError("Could not get sequence for the specified range")
+                    except ValueError as ve:
+                        QMessageBox.warning(
+                            self.view,
+                            "Range Error",
+                            f"Invalid range: {str(ve)}"
+                        )
                 else:
                     QMessageBox.warning(
                         self.view,
+                        "Gene Error",
+                        f"Could not get sequence data for gene {locus_tag}"
                     )
         except Exception as e:
+            self.logger.error(f"Error changing indices: {str(e)}")
             self.logger.error(f"Stack trace: {traceback.format_exc()}")
+            show_error(self.settings, "Error", f"Could not change sequence range: {str(e)}")
     def reset_location(self):
         """Reset gene viewer to the original sequence and location"""
                     # Get sequence directly using model's method
                     sequence = self.model._get_sequence_for_position(chrom, start, end)
                     if sequence:
+                        # Update DNA viewer with sequence
+                        self.view.dna_feature_viewer.set_data(sequence, [], start)
+                        # Update location fields - add 1 to start for display
                         self.view.line_edit_start_location.setText(str(start + 1))
                         self.view.line_edit_stop_location.setText(str(end))
+                        # Update guides display
+                        position_guides = [g for g in self.model.guides
+                                         if start <= int(g['location'].split('-')[0]) <= end]
+                        self.view.display_guides_in_table(position_guides)
                     else:
                         raise ValueError("Could not get sequence for position")
                     )
                     return
             else:
+                # For gene-based searches
                 locus_tag = current_gene.split(': ')[0] if ': ' in current_gene else current_gene
+                # Get original gene sequence
+                sequence_data = self.model.get_gene_sequence(locus_tag)
                 if sequence_data:
+                    # Get features for this gene
+                    features = self.model.get_features_for_gene(locus_tag)
+                    # Update DNA viewer with sequence and features
+                    self.view.dna_feature_viewer.set_data(
+                        sequence_data['sequence'],
+                        features,
+                        sequence_data['start']
+                    )
+                    # Update location fields - add 1 to start for display
                     self.view.line_edit_start_location.setText(str(sequence_data['start'] + 1))
                     self.view.line_edit_stop_location.setText(str(sequence_data['end']))
+                    # Update guides display
+                    gene_guides = [g for g in self.model.guides
+                                 if str(g.get('feature_id', '')).strip().lower() == locus_tag.lower()]
+                    self.view.display_guides_in_table(gene_guides)
                 else:
                     QMessageBox.warning(
                         self.view,
+                        "Gene Error",
+                        f"Could not get sequence data for gene {locus_tag}"
                     )
         except Exception as e:
             self.logger.error(f"Error in reset_location: {str(e)}")
             self.logger.error(f"Stack trace: {traceback.format_exc()}")
+            show_error(self.settings, "Reset Error", str(e))
     def select_all(self, state):
         try:
                 # Get current guides from model
                 self.model.load_guides(self.selected_targets, self.organism, self.endonuclease)
                 guides = self.model.get_guides()
+                # Clear any existing highlights and cursor
+                self._clear_viewer_state()
                 self.view.display_guides_in_table(guides)
         except Exception as e:
             show_error(self.settings, "Error refreshing guides display", str(e))
             QApplication.processEvents()
             try:
+                # Clear any existing highlights and cursor
+                self._clear_viewer_state()
                 # Load data in chunks
                 loading_dialog.set_message("Loading sequence data...", 30)
                 QApplication.processEvents()
                     self.view.line_edit_start_location.setText(str(start))
                     self.view.line_edit_stop_location.setText(str(end))
+                    # Get sequence directly for position-based search
+                    sequence = self.model._get_sequence_for_position(chrom, start, end)
+                    if sequence:
+                        # Update DNA viewer with sequence
+                        self.view.dna_feature_viewer.set_data(sequence, [], start)
+                        self.logger.debug(f"Updated gene viewer with sequence of length {len(sequence)}")
+                    else:
+                        self.logger.error(f"Could not get sequence for position {start}-{end} in chromosome {chrom}")
+                    # Filter guides for this position
+                    position_guides = [g for g in self.model.guides if g.get('feature_id') == selected_text]
                     self.view.display_guides_in_table(position_guides)
                 else:
+                    # Regular gene-based search
                     locus_tag = selected_text.split(': ')[0] if ': ' in selected_text else selected_text
+                    gene_data = self.model.get_gene_data(locus_tag)
+                    if gene_data and 'sequence' in gene_data and 'info' in gene_data:
+                        self.view.line_edit_start_location.setText(str(gene_data['info']['start'] + 1))
+                        self.view.line_edit_stop_location.setText(str(gene_data['info']['end']))
                         loading_dialog.set_message("Updating display...", 80)
                         QApplication.processEvents()
+                        # Get features and update viewer in a single call
+                        features = self.model.get_features_for_gene(locus_tag)
+                        self.view.dna_feature_viewer.set_data(gene_data['sequence'], features, gene_data['info']['start'])
+                        # Filter guides for this gene
                         gene_guides = [g for g in self.model.guides
+                                     if str(g.get('feature_id', '')).strip().lower() == locus_tag.lower()]
                         self.view.display_guides_in_table(gene_guides)
+                    else:
+                        self.logger.warning(f"No valid gene data found for locus tag: {locus_tag}")
             finally:
                 loading_dialog.close()
                         print("Negative strand")
                         # Convert sequence to complement for negative strand search
                         print(f"Sequence: {sequence_upper}")
+                        complement_sequence = ''.join({'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G',
+                                                     'K': 'M', 'Y': 'R', 'R': 'Y', 'M': 'K',
+                                                     'S': 'S'}[base] for base in sequence_upper)
                         print(f"Complement sequence: {complement_sequence}")
                         target_sequence = guide_sequence.upper()
                         print(f"Target sequence: {target_sequence}")
+                        target_sequence = target_sequence[::-1]  # Reverse the sequence
                         print(f"Reversed target sequence: {target_sequence}")
                         pos = complement_sequence.find(target_sequence)
                         print(f"Position: {pos}")
                         if pos != -1:
                             color = QColor(255, 0, 0, 100)  # Red for negative strand
                             self.logger.debug(f"Found negative strand sequence at position {pos}")
+                            # For negative strand, use the position directly but indicate strand
                             self.view.dna_feature_viewer.sequence_viewer.highlight_sequence(
                                 pos,
                                 pos + len(guide_sequence) - 1,
                 chrom = parts[0].split('chromosome')[1].strip()
                 start = int(parts[1].split('start:')[1].strip())
                 end = int(parts[2].split('end:')[1].strip())
+                self.logger.debug(f"Getting sequence for position: {chrom}:{start}-{end}")
                 sequence = self.model._get_sequence_for_position(chrom, start, end)
                 if sequence:
                     # Get features for this region
                     features = self.model.get_features_for_region(chrom, start, end)
+                    self.logger.debug(f"Got sequence of length {len(sequence)} and {len(features)} features")
+                    # Verify DNA viewer exists
+                    if not hasattr(self.view, 'dna_feature_viewer'):
+                        self.logger.error("DNA viewer not initialized!")
+                        return
+                    # Update DNA viewer directly
+                    self.view.dna_feature_viewer.set_data(sequence, features, start)
+                    self.logger.debug("Updated DNA viewer with sequence data")
+                else:
+                    self.logger.error("Failed to get sequence for position")
             else:
                 # Regular gene-based search
                 locus_tag = current_gene.split(': ')[0] if ': ' in current_gene else current_gene
                 if sequence_data and 'sequence' in sequence_data:
                     # Get features for this gene
                     features = self.model.get_features_for_gene(locus_tag)
+                    sequence = sequence_data['sequence']
+                    start_pos = sequence_data['start']
+                    self.logger.debug(f"Got sequence of length {len(sequence)}")
+                    self.logger.debug(f"First 50 chars: {sequence[:50]}")
+                    self.logger.debug(f"Start position: {start_pos}")
+                    self.logger.debug(f"Number of features: {len(features)}")
+                    # Verify DNA viewer exists
+                    if not hasattr(self.view, 'dna_feature_viewer'):
+                        self.logger.error("DNA viewer not initialized!")
+                        return
+                    # Update DNA viewer directly
+                    self.view.dna_feature_viewer.set_data(sequence, features, start_pos)
+                    self.logger.debug("Updated DNA viewer with sequence data")
                 else:
                     self.logger.warning("No sequence data available")

src/main.py CHANGED Viewed

@@ -2,42 +2,72 @@ import sys
 import os
 import platform
 from PyQt6.QtWidgets import QApplication
-from PyQt6.QtCore import Qt
 from models.GlobalSettings import GlobalSettings
 from utils.ui import show_error
 def get_app_directory():
     """Determine the application root directory based on whether we're frozen or not"""
     if hasattr(sys, 'frozen'):
         if platform.system() == 'Darwin':  # macOS
-            # Get the path to the executable inside the .app bundle
             bundle_dir = os.path.abspath(os.path.dirname(sys.executable))
-            # Navigate up to Contents directory and set Resources as app_dir
             return os.path.join(os.path.dirname(os.path.dirname(bundle_dir)), 'Contents', 'Resources')
         else:
-            # For other platforms when frozen
             return os.path.dirname(sys.executable)
     else:
-        # Development environment - go up one level from src directory
         return os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 def main():
-    RESTART_CODE = 1000  # Define restart code constant
     while True:
         app = QApplication(sys.argv)
         app.setOrganizationName("TrinhLab-UTK")
         app.setApplicationName("CASPER")
         if hasattr(Qt.ApplicationAttribute, 'AA_UseHighDpiPixmaps'):
             app.setAttribute(Qt.ApplicationAttribute.AA_UseHighDpiPixmaps)
         # Get the application directory
         app_dir_path = get_app_directory()
         try:
             global_settings = GlobalSettings(app_dir_path)
             from controllers.MainWindowController import MainWindowController
             main_window_controller = MainWindowController(global_settings)
             global_settings.set_main_window(main_window_controller)

 import os
 import platform
 from PyQt6.QtWidgets import QApplication
+from PyQt6.QtCore import Qt, QCoreApplication
 from models.GlobalSettings import GlobalSettings
 from utils.ui import show_error
+import importlib
+import concurrent.futures
+def preload_modules():
+    """Preload commonly used modules in parallel"""
+    modules_to_load = [
+        'PyQt6.QtWidgets',
+        'PyQt6.QtCore',
+        'PyQt6.QtGui',
+        'controllers.MainWindowController',
+        'views.MainWindowView',
+        'models.MainWindowModel',
+        'models.DatabaseManager',
+        'models.ConfigManager'
+    ]
+    def import_module(module_name):
+        try:
+            importlib.import_module(module_name)
+            return True, module_name
+        except Exception as e:
+            return False, f"Failed to load {module_name}: {str(e)}"
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        executor.map(import_module, modules_to_load)
 def get_app_directory():
     """Determine the application root directory based on whether we're frozen or not"""
     if hasattr(sys, 'frozen'):
         if platform.system() == 'Darwin':  # macOS
             bundle_dir = os.path.abspath(os.path.dirname(sys.executable))
             return os.path.join(os.path.dirname(os.path.dirname(bundle_dir)), 'Contents', 'Resources')
         else:
             return os.path.dirname(sys.executable)
     else:
         return os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 def main():
+    RESTART_CODE = 1000
+    # Preload modules in parallel
+    preload_modules()
     while True:
         app = QApplication(sys.argv)
         app.setOrganizationName("TrinhLab-UTK")
         app.setApplicationName("CASPER")
+        # Enable high DPI scaling
         if hasattr(Qt.ApplicationAttribute, 'AA_UseHighDpiPixmaps'):
             app.setAttribute(Qt.ApplicationAttribute.AA_UseHighDpiPixmaps)
+            app.setAttribute(Qt.ApplicationAttribute.AA_EnableHighDpiScaling, True)
+        # Enable Qt's built-in caching mechanisms
+        QCoreApplication.setAttribute(Qt.ApplicationAttribute.AA_ShareOpenGLContexts)
         # Get the application directory
         app_dir_path = get_app_directory()
         try:
             global_settings = GlobalSettings(app_dir_path)
+            # Import here after preloading
             from controllers.MainWindowController import MainWindowController
             main_window_controller = MainWindowController(global_settings)
             global_settings.set_main_window(main_window_controller)

src/models/AnnotationParser.py CHANGED Viewed

@@ -36,7 +36,6 @@ class AnnotationParser:
             if self.annotation_file_name != file_path:
                 self.annotation_file_name = file_path
-                self.logger.debug(f"Set annotation file to: {file_path}")
                 # Set index file path
                 self.index_file = f"{file_path}.index"
@@ -90,10 +89,18 @@ class AnnotationParser:
                         # Only process features with valid locus tags
                         if locus_tag and locus_tag.lower() != "n/a":
                             # Handle joined locations
                             if isinstance(feature.location, Bio.SeqFeature.CompoundLocation):
-                                if locus_tag == "CAALFM_C304810CA":
                                     print(f"Feature location: {feature.location}")
                                 # Get all parts of the joined location
                                 parts = feature.location.parts
                                 # Find min start and max end across all parts
@@ -121,10 +128,6 @@ class AnnotationParser:
                                 strand = '+' if feature.location.strand == 1 else '-'
                                 full_location = f"{start}..{end}({strand})"
-                            # Get description first since we might need it for the name
-                            description = feature.qualifiers.get('product',
-                                feature.qualifiers.get('note', ['N/A']))[0]
                             # Get gene name, use description if gene name is N/A
                             gene_name = feature.qualifiers.get('gene', ['N/A'])[0]
                             if gene_name == 'N/A':
@@ -142,35 +145,40 @@ class AnnotationParser:
                                 'end': end
                             }
-                            # Update index based on priority
                             if locus_tag in index_data['locus_tags']:
                                 existing_entry = index_data['locus_tags'][locus_tag]
                                 existing_priority = feature_priority[existing_entry['feature_type']]
                                 current_priority = feature_priority[feature.type]
                                 if current_priority >= existing_priority:
-                                    # Keep the RNA/higher priority feature type
-                                    merged_entry = existing_entry.copy()
                                     merged_entry['feature_type'] = feature.type
-                                    # Update other fields only if they're not 'N/A'
-                                    if feature_entry['gene_name'] != 'N/A':
-                                        merged_entry['gene_name'] = feature_entry['gene_name']
-                                    if feature_entry['description'] != 'N/A':
-                                        merged_entry['description'] = feature_entry['description']
-                                        # If gene name is N/A, use the new description
-                                        if merged_entry['gene_name'] == 'N/A':
-                                            merged_entry['gene_name'] = feature_entry['description']
-                                    # Always update location information
                                     merged_entry.update({
                                         'location': feature_entry['location'],
                                         'full_location': feature_entry['full_location'],
                                         'start': feature_entry['start'],
                                         'end': feature_entry['end']
                                     })
-                                    index_data['locus_tags'][locus_tag] = merged_entry
                             else:
                                 # New entry
                                 index_data['locus_tags'][locus_tag] = feature_entry
@@ -219,17 +227,17 @@ class AnnotationParser:
             self.logger.debug(f"Searching in annotation file: {self.annotation_file_name}")
             results_list = []
-            # Convert queries to lowercase set for faster lookup
             queries = {q.lower() for q in queries}
-            self.logger.debug(f"Search queries: {queries}")
             # Search through index
             if hasattr(self, '_index') and 'locus_tags' in self._index:
                 for locus_tag, feature_entry in self._index['locus_tags'].items():
                     searchable_text = ' '.join([
                         feature_entry.get('gene_name', '').lower(),
                         locus_tag.lower(),
-                        feature_entry.get('description', '').lower()
                     ])
                     # Check if any query matches
@@ -319,7 +327,6 @@ class AnnotationParser:
     def _get_sequence_for_gene(self, gene_info):
         """Get sequence for a gene from the GenBank file"""
         try:
-            self.logger.debug(f"Getting sequence for gene info: {gene_info} in _get_sequence_for_gene")
             # Parse the GenBank file and find the right record
             for record in SeqIO.parse(self.annotation_file_name, "genbank"):
                 if record.id == gene_info['chromosome']:  # Use full chromosome name
@@ -330,11 +337,39 @@ class AnnotationParser:
                     start = max(0, gene_info['start'] - padding)
                     end = min(len(sequence), gene_info['end'] + padding)
                     padded_sequence = sequence[start:end]
-                    self.logger.debug(f"Padded sequence: {padded_sequence}")
                     return padded_sequence
             return None
         except Exception as e:
             self.logger.error(f"Error getting sequence for gene: {str(e)}")
             return None

             if self.annotation_file_name != file_path:
                 self.annotation_file_name = file_path
                 # Set index file path
                 self.index_file = f"{file_path}.index"
                         # Only process features with valid locus tags
                         if locus_tag and locus_tag.lower() != "n/a":
+                            # Get description, use product as fallback
+                            description = feature.qualifiers.get('description', ['N/A'])[0]
+                            if description == 'N/A' or not description:
+                                description = feature.qualifiers.get('product', ['N/A'])[0]
+                                if locus_tag == "BN896_RS00070":
+                                    print(f"Feature description: {description}")
                             # Handle joined locations
                             if isinstance(feature.location, Bio.SeqFeature.CompoundLocation):
+                                if locus_tag == "BN896_RS00070":
                                     print(f"Feature location: {feature.location}")
+                                    # print(f"Feature product:" )
                                 # Get all parts of the joined location
                                 parts = feature.location.parts
                                 # Find min start and max end across all parts
                                 strand = '+' if feature.location.strand == 1 else '-'
                                 full_location = f"{start}..{end}({strand})"
                             # Get gene name, use description if gene name is N/A
                             gene_name = feature.qualifiers.get('gene', ['N/A'])[0]
                             if gene_name == 'N/A':
                                 'end': end
                             }
+                            # Update index based on modified priority logic
                             if locus_tag in index_data['locus_tags']:
                                 existing_entry = index_data['locus_tags'][locus_tag]
                                 existing_priority = feature_priority[existing_entry['feature_type']]
                                 current_priority = feature_priority[feature.type]
+                                # Always create a merged entry
+                                merged_entry = existing_entry.copy()
+                                # Update feature type only if priority is higher
                                 if current_priority >= existing_priority:
                                     merged_entry['feature_type'] = feature.type
+                                # Always update description if new one is not N/A
+                                if feature_entry['description'] != 'N/A':
+                                    merged_entry['description'] = feature_entry['description']
+                                    # If gene name is N/A, use the new description
+                                    if merged_entry['gene_name'] == 'N/A':
+                                        merged_entry['gene_name'] = feature_entry['description']
+                                # Update other fields if they're not 'N/A'
+                                if feature_entry['gene_name'] != 'N/A':
+                                    merged_entry['gene_name'] = feature_entry['gene_name']
+                                # Always update location information if priority is higher
+                                if current_priority >= existing_priority:
                                     merged_entry.update({
                                         'location': feature_entry['location'],
                                         'full_location': feature_entry['full_location'],
                                         'start': feature_entry['start'],
                                         'end': feature_entry['end']
                                     })
+                                index_data['locus_tags'][locus_tag] = merged_entry
                             else:
                                 # New entry
                                 index_data['locus_tags'][locus_tag] = feature_entry
             self.logger.debug(f"Searching in annotation file: {self.annotation_file_name}")
             results_list = []
             queries = {q.lower() for q in queries}
             # Search through index
             if hasattr(self, '_index') and 'locus_tags' in self._index:
                 for locus_tag, feature_entry in self._index['locus_tags'].items():
+                    # Create searchable text including feature type
                     searchable_text = ' '.join([
                         feature_entry.get('gene_name', '').lower(),
                         locus_tag.lower(),
+                        feature_entry.get('description', '').lower(),
+                        feature_entry.get('feature_type', '').lower()  # Add feature type to searchable text
                     ])
                     # Check if any query matches
     def _get_sequence_for_gene(self, gene_info):
         """Get sequence for a gene from the GenBank file"""
         try:
             # Parse the GenBank file and find the right record
             for record in SeqIO.parse(self.annotation_file_name, "genbank"):
                 if record.id == gene_info['chromosome']:  # Use full chromosome name
                     start = max(0, gene_info['start'] - padding)
                     end = min(len(sequence), gene_info['end'] + padding)
                     padded_sequence = sequence[start:end]
                     return padded_sequence
             return None
         except Exception as e:
             self.logger.error(f"Error getting sequence for gene: {str(e)}")
+            return None
+    def _get_sequence_for_position(self, chrom, start, end):
+        """Get sequence for a specific position range from the GenBank file
+        Args:
+            chrom (str): Chromosome identifier
+            start (int): Start position (0-based)
+            end (int): End position
+        Returns:
+            str: The sequence for the specified range with padding, or None if not found
+        """
+        try:
+            self.logger.debug(f"Getting sequence for position {chrom}:{start}-{end}")
+            # Parse the GenBank file and find the right record
+            for record in SeqIO.parse(self.annotation_file_name, "genbank"):
+                if record.id == chrom:  # Use full chromosome name
+                    sequence = str(record.seq)
+                    # Get sequence with padding
+                    padding = 30
+                    padded_start = max(0, start - padding)
+                    padded_end = min(len(sequence), end + padding)
+                    padded_sequence = sequence[padded_start:padded_end]
+                    return padded_sequence
+            return None
+        except Exception as e:
+            self.logger.error(f"Error getting sequence for position: {str(e)}")
             return None

src/models/BaseModel.py ADDED Viewed

	@@ -0,0 +1,58 @@

+from models.AnnotationParser import AnnotationParser
+import os
+class BaseModel:
+    def __init__(self, global_settings):
+        self.global_settings = global_settings
+        self.logger = global_settings.get_logger()
+        # Initialize the annotation parser
+        self._initialize_annotation_parser()
+        # Connect to annotation file changes
+        self.global_settings.annotation_file_changed.connect(self._on_annotation_file_changed)
+    def _initialize_annotation_parser(self) -> None:
+        """Initialize or get existing annotation parser from global settings"""
+        try:
+            # Try to get existing parser from global settings
+            if not hasattr(self.global_settings, 'annotation_parser'):
+                # Create new parser if none exists
+                annotation_file = self.global_settings.get_current_annotation_file()
+                annotation_path = os.path.join(
+                    self.global_settings.get_db_path(),
+                    'GBFF',
+                    annotation_file
+                )
+                self.global_settings.annotation_parser = AnnotationParser(self.global_settings)
+                self.global_settings.annotation_parser.set_annotation_file(annotation_path)
+                self.logger.debug("Created new annotation parser")
+            self.annotation_parser = self.global_settings.annotation_parser
+            self.annotation_path = self.annotation_parser.annotation_file_name
+        except Exception as e:
+            self.logger.error(f"Error initializing annotation parser: {str(e)}")
+            raise
+    def _on_annotation_file_changed(self, new_annotation_file):
+        """Handle annotation file changes"""
+        try:
+            self.logger.debug(f"Clearing caches for new annotation file: {new_annotation_file}")
+            self._clear_caches()
+            self._initialize_annotation_parser()
+        except Exception as e:
+            self.logger.error(f"Error handling annotation file change: {str(e)}")
+    def _clear_caches(self):
+        """Clear model-specific caches. Override in subclasses."""
+        pass
+    def cleanup(self):
+        """Cleanup resources. Override in subclasses if needed."""
+        try:
+            self.global_settings.annotation_file_changed.disconnect(self._on_annotation_file_changed)
+            self.logger.debug("Disconnected from annotation file changes")
+            self._clear_caches()
+        except Exception as e:
+            self.logger.error(f"Error in cleanup: {str(e)}")

src/models/ConfigManager.py CHANGED Viewed

@@ -94,24 +94,71 @@ class ConfigManager(QObject):
         self.env_file_created.emit()
     def write_to_env(self, key, value):
-        with open(self.env_path, 'r') as f:
-            lines = f.readlines()
-        with open(self.env_path, 'w') as f:
             for line in lines:
-                if line.startswith(f'{key}='):
-                    f.write(f'{key}="{value}"\n')  # Always use double quotes
                 else:
-                    f.write(line)
-        self.logger.info(f"Updated {key} in .env file")
     def get_env_value(self, key, default=None):
         return os.getenv(key, default)
     def set_env_value(self, key, value):
-        self.write_to_env(key, value)
-        os.environ[key] = value
-        self.logger.info(f"Set environment variable: {key}")
     def get_config_value(self, key, default=None):
         keys = key.split('.')

         self.env_file_created.emit()
     def write_to_env(self, key, value):
+        """Write or update a key-value pair in the .env file"""
+        try:
+            # Read all lines
+            if os.path.exists(self.env_path):
+                with open(self.env_path, 'r') as f:
+                    lines = f.readlines()
+            else:
+                lines = []
+            # Find if key exists
+            key_exists = False
+            new_lines = []
             for line in lines:
+                if line.strip().startswith(f'{key}='):
+                    new_lines.append(f'{key}="{value}"\n')  # Always use double quotes
+                    key_exists = True
                 else:
+                    new_lines.append(line)
+            # If key doesn't exist, append it
+            if not key_exists:
+                new_lines.append(f'{key}="{value}"\n')
+            # Write back to file
+            with open(self.env_path, 'w') as f:
+                f.writelines(new_lines)
+            # Update environment variable in memory
+            os.environ[key] = value
+            self.logger.info(f"Updated {key}={value} in .env file")
+            # Verify the write
+            with open(self.env_path, 'r') as f:
+                content = f.read()
+                if f'{key}="{value}"' not in content:
+                    self.logger.error(f"Failed to verify {key}={value} in .env file")
+                    raise Exception("Failed to verify environment variable update")
+        except Exception as e:
+            self.logger.error(f"Error writing to .env file: {str(e)}")
+            raise
     def get_env_value(self, key, default=None):
         return os.getenv(key, default)
     def set_env_value(self, key, value):
+        """Set and save an environment variable"""
+        try:
+            # Write to .env file first
+            self.write_to_env(key, value)
+            # Update runtime environment
+            os.environ[key] = value
+            # Verify the update
+            if os.getenv(key) != value:
+                self.logger.error(f"Failed to verify environment variable update for {key}")
+                raise Exception(f"Environment variable verification failed for {key}")
+            self.logger.info(f"Successfully set environment variable: {key}={value}")
+        except Exception as e:
+            self.logger.error(f"Error setting environment variable {key}: {str(e)}")
+            raise
     def get_config_value(self, key, default=None):
         keys = key.split('.')

src/models/DatabaseManager.py CHANGED Viewed

@@ -5,6 +5,7 @@ from collections import Counter
 import statistics
 from enum import Enum
 from typing import Set, Dict, List, Tuple
 class FileChangeType(Enum):
     CSPR_ADDED = "cspr_added"
@@ -23,86 +24,175 @@ class DatabaseManager(QObject):
         self.logger = logger
         self.config_manager = config_manager
         self.db_path = None
         self.file_watcher = QFileSystemWatcher()
         self.file_watcher.directoryChanged.connect(self._on_directory_changed)
         self.load_database_path()
         self._update_watched_directory()
-        self._last_cspr_files: Set[str] = set(self._get_cspr_files())
-        self._last_gbff_files: Set[str] = set(self._get_gbff_files())
     def load_database_path(self):
-        """Load the database path from .env file or set default if empty."""
-        db_path = self.config_manager.get_env_value('CSPR_DB', '')
-        # Remove both single and double quotes if present
-        db_path = db_path.strip("'\"")
-        if not db_path:
-            db_path = self.get_default_database_path()
-            self.save_db_path(db_path)
-        self.db_path = db_path
-        return self.db_path
     def validate_db_path(self, path):
-        """Validate that the given path exists and contains CSPR files"""
-        self.logger.debug(f"Validating DB path: {path}")
-        if not os.path.isdir(path):
-            self.logger.debug(f"Path is not a directory: {path}")
-            return False, "The selected path is not a directory."
-        cspr_files = self._get_cspr_files()
-        if not cspr_files:
-            self.logger.debug(f"Path {path} does not contain CSPR files")
-            return False, "The selected directory does not contain any CSPR files."
-        self.logger.debug(f"Path {path} is valid and contains {len(cspr_files)} CSPR files")
-        return True, f"Valid database path with {len(cspr_files)} CSPR files"
     def save_db_path(self, path):
         """Set and save the database path."""
-        if not path:
-            self.logger.warning("Attempting to save an empty database path")
-            return False, "Empty database path is not allowed."
-        # Ensure the path is a string and properly quoted
-        path = str(path).strip("'\"")
-        # Validate the database path
-        is_valid, message = self.validate_db_path(path)
-        if not is_valid:
-            self.logger.warning(f"Invalid database path: {path}")
-            self.db_validation_changed.emit(False, message)
-            self.db_path = path
-            self.config_manager.set_env_value('CSPR_DB', path)
-            self._update_watched_directory()
-            return False, message
-        # Set the db_path attribute
-        self.db_path = path
         try:
-            self.config_manager.set_env_value('CSPR_DB', path)
-            self.logger.info(f"Database path set and saved: {path}")
-            self.db_validation_changed.emit(True, "Database path saved successfully.")
-            self._update_watched_directory()
-            return True, "Database path saved successfully."
         except Exception as e:
-            error_message = f"Error saving database path: {str(e)}"
-            self.logger.error(error_message)
-            self.db_validation_changed.emit(False, error_message)
-            return False, error_message
     def get_db_path(self):
         return self.db_path
     def ensure_db_path_exists(self):
         """Ensure that the database path exists, creating it if necessary."""
-        if not os.path.exists(self.db_path):
             try:
-                os.makedirs(self.db_path)
-                self.logger.info(f"Created database directory: {self.db_path}")
             except Exception as e:
-                self.logger.error(f"Failed to create database directory: {self.db_path}. Error: {str(e)}")
                 raise
     def get_default_database_path(self):
@@ -190,24 +280,36 @@ class DatabaseManager(QObject):
         try:
             self.logger.debug(f"Detected change in directory: {path}")
             # Re-validate the path
             is_valid, message = self.validate_db_path(self.db_path)
             # Detect specific changes
             changes = self._detect_file_changes()
-            # Always emit validation signal on directory change
             self.db_validation_changed.emit(is_valid, message)
-            if changes:  # Only emit change signals if there are actual changes
                 self.logger.debug(f"Detected file changes: {changes}")
                 self.db_files_changed.emit(changes)
-            # Always emit combined state signal
-            self.db_state_changed.emit(is_valid, message, changes or {})
-            self.logger.info(f"Database state updated - Valid: {is_valid}, Changes: {changes}")
         except Exception as e:
             self.logger.error(f"Error handling directory change: {str(e)}")
@@ -229,23 +331,24 @@ class DatabaseManager(QObject):
                 if f.endswith('.gbff')]
     def check_db_state(self):
-        """Check the current state of the database and emit signals if needed."""
-        self.logger.debug("Checking database state")
-        if not self.db_path:
-            self.load_database_path()
-        # Get validation state
-        is_valid, message = self.validate_db_path(self.db_path)
-        # Detect any changes since last check
-        changes = self._detect_file_changes()
-        # Emit signals
-        self.db_validation_changed.emit(is_valid, message)
-        if changes:
-            self.db_files_changed.emit(changes)
-        self.logger.info(f"Database state checked - Valid: {is_valid}, Changes: {changes}")
     def get_organisms_and_endos(self):
         """Get mapping of organisms to their endonucleases and files"""
@@ -510,3 +613,105 @@ class DatabaseManager(QObject):
         except Exception as e:
             self.logger.error(f"Error calculating statistics: {str(e)}")
             raise

 import statistics
 from enum import Enum
 from typing import Set, Dict, List, Tuple
+import glob
 class FileChangeType(Enum):
     CSPR_ADDED = "cspr_added"
         self.logger = logger
         self.config_manager = config_manager
         self.db_path = None
+        self.pending_db_path = None
+        self.is_changing_directory = False
+        self._is_validating = False  # Add flag to prevent recursion
+        # Initialize last known states before file watcher
+        self._last_cspr_files = set()
+        self._last_gbff_files = set()
+        self._last_files = {}  # Track files in each watched directory
+        # Initialize file watcher
         self.file_watcher = QFileSystemWatcher()
         self.file_watcher.directoryChanged.connect(self._on_directory_changed)
+        # Load database path and update states
         self.load_database_path()
         self._update_watched_directory()
+        # Update last known states after path is loaded
+        self._last_cspr_files = set(self._get_cspr_files())
+        self._last_gbff_files = set(self._get_gbff_files())
+        if self.db_path:
+            self._last_files[self.db_path] = set(os.listdir(self.db_path))
+            gbff_path = os.path.join(self.db_path, 'GBFF')
+            if os.path.exists(gbff_path):
+                self._last_files[gbff_path] = set(os.listdir(gbff_path))
     def load_database_path(self):
+        """Load the database path from .env file."""
+        try:
+            db_path = self.config_manager.get_env_value('CSPR_DB', '')
+            # Remove both single and double quotes if present
+            db_path = db_path.strip("'\"")
+            # Only set default if no path exists at all
+            if not db_path and self.config_manager.get_env_value('FIRST_TIME_START', 'TRUE').upper() == 'TRUE':
+                db_path = self.get_default_database_path()
+                self.save_db_path(db_path)
+            self.db_path = db_path
+            self.logger.debug(f"Database path loaded from .env: {self.db_path}")
+            return self.db_path
+        except Exception as e:
+            self.logger.error(f"Error loading database path: {str(e)}")
+            return self.get_default_database_path()
     def validate_db_path(self, path):
+        """
+        Validate the database path without modifying it
+        Returns (is_valid, message)
+        """
+        try:
+            if not path:
+                return False, "No directory selected"
+            if not os.path.exists(path):
+                return False, "The selected directory does not exist."
+            # Check for CSPR files
+            cspr_files = glob.glob(os.path.join(path, "*.cspr"))
+            if not cspr_files:
+                return False, "No CSPR files found"
+            return True, "Valid database directory"
+        except Exception as e:
+            self.logger.error(f"Error validating database path: {str(e)}")
+            return False, str(e)
     def save_db_path(self, path):
         """Set and save the database path."""
+        if self._is_validating:  # Prevent recursive validation
+            return True, "Operation in progress"
+        try:
+            self._is_validating = True
+            if not path:
+                self.logger.warning("Attempting to save an empty database path")
+                return False, "Empty database path is not allowed."
+            path = str(path).strip("'\"")
+            is_new_genome = self._is_new_genome_context()
+            # Validate the database path
+            is_valid, message = self.validate_db_path(path)
+            # Log the current state
+            self.logger.debug(f"Saving DB path - Current state: db_path={self.db_path}, pending={self.pending_db_path}, "
+                             f"is_changing={self.is_changing_directory}, is_new_genome={is_new_genome}")
+            # If we're in new genome context or path change context, store as pending path
+            if is_new_genome or is_valid:
+                self.logger.debug(f"Storing pending database path: {path}")
+                self.pending_db_path = path
+                self.is_changing_directory = True
+                # Create directory if needed
+                if not os.path.exists(path):
+                    try:
+                        os.makedirs(path)
+                        self.logger.info(f"Created pending directory: {path}")
+                    except Exception as e:
+                        self.logger.error(f"Error creating pending directory: {str(e)}")
+                # If the path is valid, finalize the change immediately
+                if is_valid:
+                    success, finalize_message = self.finalize_directory_change()
+                    if not success:
+                        self.logger.error(f"Failed to finalize directory change: {finalize_message}")
+                        return False, finalize_message
+                    return True, finalize_message
+                return True, "Path stored for new genome creation"
+            # For invalid paths
+            if not is_valid:
+                self.db_validation_changed.emit(False, message)
+                return False, message
+        finally:
+            self._is_validating = False
+    def _is_new_genome_context(self):
+        """Check if the path change is happening in new genome context"""
         try:
+            import inspect
+            stack = inspect.stack()
+            # Check for NCBI context as well
+            is_new_genome = any('NewGenome' in frame.filename or 'NCBI' in frame.filename for frame in stack)
+            is_path_change = any('MainWindow' in frame.filename and 'change_database_directory' in frame.function
+                               for frame in stack)
+            # Consider it a new genome context if either:
+            # 1. We're in new genome/NCBI context and actively changing directory
+            # 2. We're in the path change process
+            is_active_change = (is_new_genome and self.is_changing_directory) or is_path_change
+            self.logger.debug(f"Context check - New Genome: {is_new_genome}, Path Change: {is_path_change}, "
+                             f"Active Change: {is_active_change}, Is Changing Directory: {self.is_changing_directory}")
+            return is_active_change
         except Exception as e:
+            self.logger.error(f"Error in _is_new_genome_context: {str(e)}")
+            return False
+    def get_active_db_path(self):
+        """Get the appropriate database path based on context"""
+        if self.pending_db_path and self.is_changing_directory:
+            self.logger.debug(f"Using pending database path: {self.pending_db_path}")
+            return self.pending_db_path
+        self.logger.debug(f"Using current database path: {self.db_path}")
+        return self.db_path
     def get_db_path(self):
         return self.db_path
     def ensure_db_path_exists(self):
         """Ensure that the database path exists, creating it if necessary."""
+        path_to_check = self.get_active_db_path()  # Use active path instead of db_path
+        if not os.path.exists(path_to_check):
             try:
+                os.makedirs(path_to_check)
+                self.logger.info(f"Created database directory: {path_to_check}")
             except Exception as e:
+                self.logger.error(f"Failed to create database directory: {path_to_check}. Error: {str(e)}")
                 raise
     def get_default_database_path(self):
         try:
             self.logger.debug(f"Detected change in directory: {path}")
+            # Check if change is just an index file
+            changed_files = set(os.listdir(path)) - set(self._last_files.get(path, []))
+            if all(f.endswith('.index') for f in changed_files):
+                self.logger.debug("Ignoring index file changes")
+                # Update last files without triggering refresh
+                self._last_files[path] = set(os.listdir(path))
+                return
+            # Get current state of CSPR files
+            current_cspr_files = set(self._get_cspr_files())
             # Re-validate the path
             is_valid, message = self.validate_db_path(self.db_path)
             # Detect specific changes
             changes = self._detect_file_changes()
+            # Update last known state
+            self._last_cspr_files = current_cspr_files
+            self._last_files[path] = set(os.listdir(path))
+            # Always emit validation and state changes
             self.db_validation_changed.emit(is_valid, message)
+            self.db_state_changed.emit(is_valid, message, changes)
+            # If changes detected, emit files changed signal
+            if changes:
                 self.logger.debug(f"Detected file changes: {changes}")
                 self.db_files_changed.emit(changes)
         except Exception as e:
             self.logger.error(f"Error handling directory change: {str(e)}")
                 if f.endswith('.gbff')]
     def check_db_state(self):
+        """
+        Check database state without clearing invalid paths
+        """
+        try:
+            current_path = self.get_db_path()
+            is_valid, message = self.validate_db_path(current_path)
+            # Get list of changes if path is valid
+            changes = {}  # Initialize as dict instead of list
+            if is_valid:
+                changes = self._detect_file_changes()
+            # Emit signals but don't modify the path
+            self.db_validation_changed.emit(is_valid, message)
+            self.db_state_changed.emit(is_valid, message, changes)
+        except Exception as e:
+            self.logger.error(f"Error checking database state: {str(e)}")
     def get_organisms_and_endos(self):
         """Get mapping of organisms to their endonucleases and files"""
         except Exception as e:
             self.logger.error(f"Error calculating statistics: {str(e)}")
             raise
+    def update_db_state(self):
+        """Check and update the database state"""
+        self.logger.debug("Checking database state")
+        if not self.db_path and not self.pending_db_path:
+            self.load_database_path()
+        # Use active path for validation
+        path_to_check = self.get_active_db_path()
+        self.logger.debug(f"Checking state for path: {path_to_check} (pending: {self.pending_db_path}, current: {self.db_path})")
+        is_valid, message = self.validate_db_path(path_to_check)
+        self.logger.debug(f"Database validation result - Path: {path_to_check}, Valid: {is_valid}, Message: {message}")
+        # Detect any changes since last check
+        changes = self._detect_file_changes()
+        # Check if we should finalize a directory change
+        if self.pending_db_path and self.is_changing_directory:
+            self.logger.debug("Checking conditions for directory change finalization")
+            self.logger.debug(f"Is valid: {is_valid}, Has changes: {bool(changes)}")
+            if is_valid and not changes:  # No changes means we're not in the middle of file operations
+                self.logger.debug("Attempting to finalize directory change")
+                success, finalize_message = self.finalize_directory_change()
+                if success:
+                    self.logger.debug("Directory change finalized successfully")
+                    # Emit signals
+                    self.db_validation_changed.emit(True, finalize_message)
+                    self.db_state_changed.emit(True, finalize_message, changes)
+                    return
+                else:
+                    self.logger.debug(f"Directory change finalization failed: {finalize_message}")
+        # Emit regular signals
+        self.db_validation_changed.emit(is_valid, message)
+        if changes:
+            self.db_files_changed.emit(changes)
+        self.logger.info(f"Database state checked - Valid: {is_valid}, Changes: {changes}")
+    def cancel_directory_change(self):
+        """Cancel the directory change process"""
+        self.logger.debug(f"Cancelling directory change process. Previous state - Pending: {self.pending_db_path}, Changing: {self.is_changing_directory}")
+        self.pending_db_path = None
+        self.is_changing_directory = False
+        self.logger.debug("Directory change process cancelled")
+    def finalize_directory_change(self):
+        """Finalize the database directory change after successful validation"""
+        try:
+            if self.pending_db_path and self.is_changing_directory:
+                self.logger.debug(f"Finalizing directory change from {self.db_path} to {self.pending_db_path}")
+                # Validate the pending path one final time
+                is_valid, message = self.validate_db_path(self.pending_db_path)
+                if not is_valid:
+                    self.logger.warning(f"Cannot finalize directory change: {message}")
+                    return False, message
+                # Update the current path
+                old_path = self.db_path
+                self.db_path = self.pending_db_path
+                # Update .env file - try multiple approaches to ensure it works
+                try:
+                    # First attempt: Direct write
+                    self.config_manager.write_to_env('CSPR_DB', self.db_path)
+                    # Second attempt: Use set_env_value
+                    self.config_manager.set_env_value('CSPR_DB', self.db_path)
+                    # Force reload environment variables
+                    self.config_manager.load_env()
+                    # Verify the update
+                    new_env_value = self.config_manager.get_env_value('CSPR_DB')
+                    if new_env_value != self.db_path:
+                        raise Exception(f"Environment variable update failed. Expected: {self.db_path}, Got: {new_env_value}")
+                except Exception as e:
+                    self.logger.error(f"Error updating environment variable: {str(e)}")
+                    return False, f"Failed to update environment variable: {str(e)}"
+                # Clear pending state
+                self.pending_db_path = None
+                self.is_changing_directory = False
+                # Update database state
+                self.update_db_state()
+                success_message = f"Successfully changed database directory to:\n{self.db_path}"
+                self.logger.info(f"Successfully changed database directory from {old_path} to {self.db_path}")
+                self.logger.debug("Directory change finalized successfully")
+                return True, success_message
+            return False, "No pending directory change to finalize"
+        except Exception as e:
+            self.logger.error(f"Error finalizing directory change: {str(e)}")
+            return False, f"Error finalizing directory change: {str(e)}"

src/models/FindTargetsModel.py CHANGED Viewed

@@ -1,21 +1,19 @@
-from models.HomeWindowModel import HomeWindowModel
 from models.CSPRparser import CSPRparser
 from models.AnnotationParser import AnnotationParser
 import os
 from functools import lru_cache
 import traceback
 from Bio import SeqIO
-class FindTargetsModel(HomeWindowModel):
     def __init__(self, global_settings):
         super().__init__(global_settings)
         self.results = {}
-        self._parser_cache = {}
-        self.global_settings.annotation_file_changed.connect(self._on_annotation_file_changed)
-    def _on_annotation_file_changed(self, new_annotation_file):
-        """Clear caches when annotation file changes"""
-        self.global_settings.logger.debug(f"FindTargetsModel clearing caches for new annotation file: {new_annotation_file}")
         self._parser_cache.clear()
     @lru_cache(maxsize=32)
@@ -26,11 +24,9 @@ class FindTargetsModel(HomeWindowModel):
         return self._parser_cache[file_path]
     def find_targets(self, input_data):
-        self.global_settings.logger.debug(f"Received input data: {input_data}")
         organism = input_data['organism']
         endo = input_data['endonuclease']
-        org_files = self.get_organism_to_files()
         self._validate_input(organism, endo, org_files)
@@ -46,7 +42,7 @@ class FindTargetsModel(HomeWindowModel):
         search_func = search_types.get(input_data['search_type'])
         if not search_func:
             error_msg = f"Invalid search type: {input_data['search_type']}"
-            self.global_settings.logger.error(error_msg)
             raise ValueError(error_msg)
         self.results = search_func(parser, input_data)
@@ -56,12 +52,12 @@ class FindTargetsModel(HomeWindowModel):
     def _validate_input(self, organism, endo, org_files):
         if organism not in org_files:
             error_msg = f"Organism '{organism}' not found in the database. Available organisms: {list(org_files.keys())}"
-            self.global_settings.logger.error(error_msg)
             raise ValueError(error_msg)
         if endo not in org_files[organism]:
             error_msg = f"Endonuclease '{endo}' not found for organism '{organism}'. Available endonucleases: {list(org_files[organism].keys())}"
-            self.global_settings.logger.error(error_msg)
             raise ValueError(error_msg)
     def find_targets_by_feature(self, parser, input_data):
@@ -84,18 +80,17 @@ class FindTargetsModel(HomeWindowModel):
                 self.global_settings.logger.error(f"Annotation file not found: {annotation_file_path}")
                 raise FileNotFoundError(f"Annotation file not found: {annotation_file_path}")
-            self.global_settings.logger.debug(f"Using annotation file: {annotation_file_path}")
             # Split search queries by newlines and remove empty lines
             search_queries = [q.strip() for q in input_data['search_query'].split('\n') if q.strip()]
-            annotation_parser = AnnotationParser(self.global_settings)
-            annotation_parser.set_annotation_file(annotation_file_path)
             # Process each query and combine results
             all_results = []
             for search_query in search_queries:
-                results_list = annotation_parser.genbank_search([search_query])
                 for record_id, feature_info in results_list:
                     location = feature_info['feature_location']
@@ -355,3 +350,11 @@ class FindTargetsModel(HomeWindowModel):
                 'endonuclease': target[5]
             })
         return formatted_results

 from models.CSPRparser import CSPRparser
+from models.BaseModel import BaseModel
 from models.AnnotationParser import AnnotationParser
 import os
 from functools import lru_cache
 import traceback
 from Bio import SeqIO
+class FindTargetsModel(BaseModel):
     def __init__(self, global_settings):
         super().__init__(global_settings)
         self.results = {}
+        self._parser_cache = {}
+    def _clear_caches(self):
+        """Clear all model-specific caches"""
         self._parser_cache.clear()
     @lru_cache(maxsize=32)
         return self._parser_cache[file_path]
     def find_targets(self, input_data):
         organism = input_data['organism']
         endo = input_data['endonuclease']
+        org_files = self.global_settings.get_organism_files()
         self._validate_input(organism, endo, org_files)
         search_func = search_types.get(input_data['search_type'])
         if not search_func:
             error_msg = f"Invalid search type: {input_data['search_type']}"
+            self.logger.error(error_msg)
             raise ValueError(error_msg)
         self.results = search_func(parser, input_data)
     def _validate_input(self, organism, endo, org_files):
         if organism not in org_files:
             error_msg = f"Organism '{organism}' not found in the database. Available organisms: {list(org_files.keys())}"
+            self.logger.error(error_msg)
             raise ValueError(error_msg)
         if endo not in org_files[organism]:
             error_msg = f"Endonuclease '{endo}' not found for organism '{organism}'. Available endonucleases: {list(org_files[organism].keys())}"
+            self.logger.error(error_msg)
             raise ValueError(error_msg)
     def find_targets_by_feature(self, parser, input_data):
                 self.global_settings.logger.error(f"Annotation file not found: {annotation_file_path}")
                 raise FileNotFoundError(f"Annotation file not found: {annotation_file_path}")
             # Split search queries by newlines and remove empty lines
             search_queries = [q.strip() for q in input_data['search_query'].split('\n') if q.strip()]
+            # Use existing annotation parser from BaseModel
+            if self.annotation_parser.annotation_file_name != annotation_file_path:
+                self.annotation_parser.set_annotation_file(annotation_file_path)
             # Process each query and combine results
             all_results = []
             for search_query in search_queries:
+                results_list = self.annotation_parser.genbank_search([search_query])
                 for record_id, feature_info in results_list:
                     location = feature_info['feature_location']
                 'endonuclease': target[5]
             })
         return formatted_results
+    def get_cspr_file_path(self, input_data):
+        """Get the path to the CSPR file for the given input data"""
+        org_files = self.global_settings.get_organism_files()
+        return os.path.join(
+            self.global_settings.get_db_path(),
+            org_files[input_data['organism']][input_data['endonuclease']][0]
+        )

src/models/GenerateLibraryModel.py CHANGED Viewed

@@ -1,21 +1,30 @@
 from models.CSPRparser import CSPRparser
-from models.HomeWindowModel import HomeWindowModel
 import os
 import re
 import traceback
-class GenerateLibraryModel(HomeWindowModel):
     def __init__(self, global_settings):
-        super().__init__(global_settings)
         self.logger = global_settings.logger
         self.parser = None
         self.targets_data = {}
         self._deleted_targets = {}
     def initialize_parser(self, cspr_file):
         """Initialize CSPR parser"""
         self.parser = CSPRparser(cspr_file, self.global_settings.get_casper_info_path())
     def generate_library(self, selected_targets, settings):
         """Generate library with given settings"""
         try:
@@ -29,26 +38,114 @@ class GenerateLibraryModel(HomeWindowModel):
                 settings['target_range_start'],
                 settings['target_range_end']
             )
-            # Generate output for each target
             output_data = self._generate_output(
                 processed_targets,
                 settings['guides_per_gene'],
                 settings['space_between_guides']
             )
-            self.logger.debug(f"Output data: {output_data}")
             # Write output to file
             self._write_output(output_data, settings)
-            return True
         except Exception as e:
-            self.logger.error(f"Error generating library: {str(e)}")
-            self.logger.error(traceback.format_exc())
             raise
     def _process_targets(self, targets, min_score, five_prime_seq, start_range, end_range):
         """Process and filter targets based on criteria"""
         processed = {}
@@ -73,17 +170,11 @@ class GenerateLibraryModel(HomeWindowModel):
             else:
                 self._deleted_targets[gene_name].append(target_data)
-        # Sort targets for each gene
         for gene in processed:
-            # First sort by score (ascending)
-            processed[gene].sort(key=lambda x: float(x['score']))
-            # Then sort by position (ascending)
-            processed[gene].sort(key=lambda x: abs(int(x['position'])))
-            # Reverse list if gene is on negative strand
-            if processed[gene] and processed[gene][0].get('strand', '+') == '-':
-                processed[gene].reverse()
         return processed
@@ -93,14 +184,18 @@ class GenerateLibraryModel(HomeWindowModel):
             # Score filter - convert score to float and compare
             target_score = float(target.get('score', 0))
             if target_score < min_score:
-                self.logger.debug(f"Target failed score filter: {target_score} < {min_score}")
                 return False
-            # Poly-T filter
             if re.search("T{5,10}", target['sequence']):
                 self.logger.debug(f"Target failed poly-T filter: {target['sequence']}")
                 return False
             # 5' sequence filter
             if five_prime_seq and not target['sequence'].startswith(five_prime_seq.upper()):
                 self.logger.debug(f"Target failed 5' sequence filter")
@@ -146,47 +241,77 @@ class GenerateLibraryModel(HomeWindowModel):
             return 0
     def _generate_output(self, processed_targets, guides_per_gene, space_between):
         output = {}
         for gene_id, targets in processed_targets.items():
             output[gene_id] = []
-            i = 0
-            vec_index = 0
             prev_target = None
             while i < guides_per_gene:
                 if len(targets) == 0 or vec_index >= len(targets):
                     break
                 current = targets[vec_index]
-                # Check spacing from previous target
-                if prev_target is None or abs(int(current['position']) - int(prev_target['position'])) >= space_between:
-                    # If current target has better score than previous
-                    if (prev_target and float(current['score']) > float(prev_target['score'])):
-                        output[gene_id].pop()
-                        output[gene_id].append(current)
-                    else:
-                        output[gene_id].append(current)
                     prev_target = current
                     i += 1
                 vec_index += 1
-                if vec_index >= len(targets):
-                    break
-            # Add deleted targets if needed
-            if len(output[gene_id]) < guides_per_gene:
-                deleted_sorted = sorted(
-                    self._deleted_targets.get(gene_id, []),
-                    key=lambda x: (float(x['score']), abs(int(x['position'])))
-                )
-                for deleted_target in deleted_sorted:
-                    if len(output[gene_id]) >= guides_per_gene:
-                        break
-                    deleted_target['modified'] = True
-                    output[gene_id].append(deleted_target)
         return output

 from models.CSPRparser import CSPRparser
+from models.OffTargetModel import OffTargetModel
 import os
 import re
 import traceback
+from PyQt6.QtCore import QObject, pyqtSignal
+class GenerateLibraryModel(QObject):
+    progress_updated = pyqtSignal(int)  # Signal to emit progress updates
     def __init__(self, global_settings):
+        super().__init__()
+        self.global_settings = global_settings
         self.logger = global_settings.logger
         self.parser = None
         self.targets_data = {}
         self._deleted_targets = {}
+        self.off_target_model = OffTargetModel(global_settings)
     def initialize_parser(self, cspr_file):
         """Initialize CSPR parser"""
         self.parser = CSPRparser(cspr_file, self.global_settings.get_casper_info_path())
+    def get_organism_to_files(self):
+        """Get mapping of organisms to their files from global settings"""
+        return self.global_settings.get_organism_files()
     def generate_library(self, selected_targets, settings):
         """Generate library with given settings"""
         try:
                 settings['target_range_start'],
                 settings['target_range_end']
             )
+            if settings.get('find_off_targets'):
+                # Write targets to temp file for off-target analysis
+                self._write_targets_to_temp(processed_targets)
+                # Get organism and endonuclease from home window
+                if hasattr(self.global_settings, '_current_home_window'):
+                    organism = self.global_settings._current_home_window.view.combo_box_organism.currentText()
+                    endonuclease = self.global_settings._current_home_window.view.combo_box_endonuclease.currentText()
+                else:
+                    raise ValueError("Could not access home window to get organism and endonuclease")
+                if not organism or not endonuclease:
+                    raise ValueError("Could not determine organism or endonuclease from home window")
+                self.logger.debug(f"Using organism: {organism} and endonuclease: {endonuclease} for off-target analysis")
+                # Setup off-target parameters
+                off_target_params = {
+                    'organism': organism,
+                    'endonuclease': endonuclease,
+                    'max_mismatches': 4,  # Default value from old implementation
+                    'tolerance': 0.05,  # Default value from old implementation
+                    'average_output': True,
+                    'save_output': False,
+                    'output_filename': '',
+                    'targets': selected_targets,
+                    'annotation_file': self.global_settings.get_current_annotation_file()
+                }
+                # Connect to off-target model signals
+                self.off_target_model.progress_updated.connect(self._handle_off_target_progress)
+                self.off_target_model.results_ready.connect(lambda results: self._handle_off_target_results(results, processed_targets, settings))
+                # Start off-target analysis
+                self.off_target_model.start_analysis(off_target_params)
+                return True
+            else:
+                # Generate output for each target
+                output_data = self._generate_output(
+                    processed_targets,
+                    settings['guides_per_gene'],
+                    settings['space_between_guides']
+                )
+                self.logger.debug(f"Output data: {output_data}")
+                # Write output to file
+                self._write_output(output_data, settings)
+                return True
+        except Exception as e:
+            self.logger.error(f"Error generating library: {str(e)}")
+            self.logger.error(traceback.format_exc())
+            raise
+    def _write_targets_to_temp(self, processed_targets):
+        """Write targets to temp file for off-target analysis"""
+        try:
+            temp_path = os.path.join(self.global_settings.get_db_path(), 'temp.txt')
+            with open(temp_path, 'w') as f:
+                for gene in processed_targets:
+                    for target in processed_targets[gene]:
+                        # Format: position;sequence;pam;score;strand
+                        entry = f"{target['position']};{target['sequence']};{target['pam']};{target['score']};{target['strand']}\n"
+                        f.write(entry)
+            self.logger.debug(f"Wrote targets to temp file: {temp_path}")
+        except Exception as e:
+            self.logger.error(f"Error writing targets to temp file: {str(e)}")
+            raise
+    def _handle_off_target_progress(self, value, status):
+        """Handle progress updates from off-target analysis"""
+        self.progress_updated.emit(value)
+    def _handle_off_target_results(self, results, processed_targets, settings):
+        """Handle results from off-target analysis"""
+        try:
+            scores_dict, _ = results
+            # Update targets with off-target scores
+            for gene in processed_targets:
+                for target in processed_targets[gene]:
+                    if target['sequence'] in scores_dict:
+                        target['off_target_score'] = scores_dict[target['sequence']]
+            # Generate output with updated targets
             output_data = self._generate_output(
                 processed_targets,
                 settings['guides_per_gene'],
                 settings['space_between_guides']
             )
             # Write output to file
             self._write_output(output_data, settings)
+            # Clean up temp file
+            temp_path = os.path.join(self.global_settings.get_db_path(), 'temp.txt')
+            if os.path.exists(temp_path):
+                os.remove(temp_path)
         except Exception as e:
+            self.logger.error(f"Error handling off-target results: {str(e)}")
             raise
     def _process_targets(self, targets, min_score, five_prime_seq, start_range, end_range):
         """Process and filter targets based on criteria"""
         processed = {}
             else:
                 self._deleted_targets[gene_name].append(target_data)
+        # Log first 5 targets for each gene for debugging
         for gene in processed:
+            if processed[gene]:
+                self.logger.debug(f"First 5 targets for gene {gene}: {[t['score'] for t in processed[gene][:5]]}")
+                self.logger.debug(f"First 5 target positions for gene {gene}: {[t['position'] for t in processed[gene][:5]]}")
         return processed
             # Score filter - convert score to float and compare
             target_score = float(target.get('score', 0))
             if target_score < min_score:
+                self.logger.debug(f"Target failed score filter: {target_score} < {min_score}, target: {target}")
                 return False
+            self.logger.debug(f"Target passed score filter: {target_score} >= {min_score}, target: {target}")
+            # Poly-T filter (5-10 consecutive T's)
             if re.search("T{5,10}", target['sequence']):
                 self.logger.debug(f"Target failed poly-T filter: {target['sequence']}")
                 return False
+            self.logger.debug(f"Target passed poly-T filter: {target['sequence']}")
             # 5' sequence filter
             if five_prime_seq and not target['sequence'].startswith(five_prime_seq.upper()):
                 self.logger.debug(f"Target failed 5' sequence filter")
             return 0
     def _generate_output(self, processed_targets, guides_per_gene, space_between):
+        """Generate output with proper spacing between guides"""
         output = {}
         for gene_id, targets in processed_targets.items():
             output[gene_id] = []
+            # First sort by score (descending)
+            targets.sort(key=lambda x: float(x['score']), reverse=True)
+            self.logger.debug(f"First 5 targets positions for gene {gene_id} by score: {[(t['position'], t['score']) for t in targets[:5]]}")
+            # Then sort by position
+            targets.sort(key=lambda x: abs(int(x['position'])))
+            self.logger.debug(f"First 5 targets positions for gene {gene_id}: {[t['position'] for t in targets[:5]]}")
+            i = 0  # Counter for selected guides
+            vec_index = 0  # Index for current target being considered
             prev_target = None
             while i < guides_per_gene:
                 if len(targets) == 0 or vec_index >= len(targets):
                     break
                 current = targets[vec_index]
+                # For first target, just add it
+                if prev_target is None:
+                    output[gene_id].append(current)
                     prev_target = current
                     i += 1
+                else:
+                    # Check spacing from previous target
+                    distance = abs(int(current['position']) - int(prev_target['position']))
+                    if distance >= space_between:
+                        # Look ahead for better scoring targets within this space
+                        best_target = current
+                        look_ahead_index = vec_index + 1
+                        while look_ahead_index < len(targets):
+                            next_target = targets[look_ahead_index]
+                            next_distance = abs(int(next_target['position']) - int(prev_target['position']))
+                            # If we've gone too far, break
+                            if next_distance >= space_between:
+                                break
+                            # If this target has better score
+                            if float(next_target['score']) > float(best_target['score']):
+                                best_target = next_target
+                            look_ahead_index += 1
+                        output[gene_id].append(best_target)
+                        prev_target = best_target
+                        i += 1
+                        # Move vec_index past the selected target's position
+                        while vec_index < len(targets) and abs(int(targets[vec_index]['position'])) <= abs(int(best_target['position'])):
+                            vec_index += 1
+                        continue
                 vec_index += 1
+            # Sort final output by position
+            output[gene_id].sort(key=lambda x: abs(int(x['position'])))
+            # If gene is on negative strand, reverse the order
+            if output[gene_id] and output[gene_id][0].get('strand', '+') == '-':
+                output[gene_id].reverse()
+            self.logger.debug(f"Selected targets positions for gene {gene_id}: {[t['position'] for t in output[gene_id]]}")
         return output

src/models/GlobalSettings.py CHANGED Viewed

@@ -68,21 +68,46 @@ class GlobalSettings(QObject):
         self._preloading_modules = {}
         self.main_window = None
-        # Only preload essential controllers for startup
-        self._preload_essential_controllers()
-        # Start background loading of commonly used modules
-        self._background_load_common_modules()
         self.config_manager = ConfigManager(app_dir_path=self.app_dir_path, logger=self.logger)
         self.config_manager.load_env()
         self.is_first_time_startup = self.config_manager.get_env_value('FIRST_TIME_START', 'TRUE').upper() == 'TRUE'
-        # Defer database initialization until needed
-        self._initialize_directories()
         self._init_db_manager()
         # Defer theme initialization
         self._init_theme_settings()
@@ -170,6 +195,8 @@ class GlobalSettings(QObject):
     def validate_db_path(self, path):
         """Validate the given database path"""
         return self.db_manager.validate_db_path(path)
     def save_db_path(self, path):
@@ -295,8 +322,6 @@ class GlobalSettings(QObject):
     def _get_window_class(self, window_name):
         """Get the controller class with optimized loading"""
         try:
-            start_time = time.time()
             # Check if module is already cached
             module_path = f"controllers.{window_name}Controller"
             if module_path in self._module_cache:
@@ -329,7 +354,6 @@ class GlobalSettings(QObject):
             if not hasattr(controller_module, class_name):
                 raise AttributeError(f"Controller module does not contain class {class_name}")
-            self.logger.debug(f"Window class retrieval took: {time.time() - start_time:.2f} seconds")
             return getattr(controller_module, class_name)
         except Exception as e:
@@ -350,11 +374,15 @@ class GlobalSettings(QObject):
             self.logger.error(f"Error creating window {window_name}: {str(e)}")
             raise
-    def get_startup_window(self):
-        if not hasattr(self, '_startup_window'):
-            from controllers.StartupWindowController import StartupWindowController
-            self._startup_window = StartupWindowController(self)
-        return self._startup_window
     def get_home_window(self):
         """Get or create home window with proper initialization"""
@@ -391,7 +419,13 @@ class GlobalSettings(QObject):
     def _background_load_common_modules(self):
         """Start background loading of commonly used modules"""
         try:
-            common_modules = ["MultitargetingWindow", "PopulationAnalysisWindow"]
             for module_name in common_modules:
                 if (module_name not in self._module_cache and
                     module_name not in self._preloading_modules):
@@ -411,7 +445,6 @@ class GlobalSettings(QObject):
                 preloader = self._preloading_modules[module_name]
                 if not preloader.isRunning():  # Only remove if thread is finished
                     del self._preloading_modules[module_name]
-            self.logger.debug(f"Module {module_name} preloaded successfully")
         except Exception as e:
             self.logger.error(f"Error handling preloaded module: {str(e)}")
@@ -501,29 +534,15 @@ class GlobalSettings(QObject):
     def set_current_annotation_file(self, annotation_file):
         """Set the current annotation file and notify listeners"""
         try:
-            if not hasattr(self, '_current_annotation_file'):
-                self._current_annotation_file = None
             if self._current_annotation_file != annotation_file:
                 self._current_annotation_file = annotation_file
-                self.logger.debug(f"Current annotation file changed to: {annotation_file}")
                 self.annotation_file_changed.emit(annotation_file)
         except Exception as e:
             self.logger.error(f"Error setting current annotation file: {str(e)}")
     def get_current_annotation_file(self):
         """Get the currently selected annotation file"""
-        try:
-            if not self._current_annotation_file and hasattr(self, '_current_home_window'):
-                # Try to get from home window if not set
-                home_controller = self._current_home_window
-                if hasattr(home_controller, 'view'):
-                    self._current_annotation_file = home_controller.view.get_annotation_file()
-                    self.logger.debug(f"Got annotation file from home window: {self._current_annotation_file}")
-            return self._current_annotation_file
-        except Exception as e:
-            self.logger.error(f"Error getting current annotation file: {str(e)}")
-            return None
     def get_scoring_options_window(self, view_targets_controller):
         """Create and return ScoringOptionsController instance"""
@@ -575,5 +594,125 @@ class GlobalSettings(QObject):
             self.logger.error(f"Error adjusting path: {str(e)}")
             return path  # Return original path if adjustment fails
 # Global instance
 global_settings = None

         self._preloading_modules = {}
         self.main_window = None
+        # Initialize config manager first
         self.config_manager = ConfigManager(app_dir_path=self.app_dir_path, logger=self.logger)
         self.config_manager.load_env()
+        # Initialize directories
+        self._initialize_directories()
+        # Check if there are CSPR files in the current database path
+        current_db_path = self.config_manager.get_env_value('CSPR_DB', '')
+        if current_db_path:
+            try:
+                import glob, os
+                cspr_files = glob.glob(os.path.join(current_db_path, "*.cspr"))
+                if not cspr_files:
+                    # No CSPR files found, but keep the path
+                    self.logger.info(f"No CSPR files found in {current_db_path}, but keeping the path")
+                    # Only set first time startup to TRUE if there was no previous path
+                    if not self.config_manager.get_env_value('CSPR_DB', ''):
+                        self.config_manager.set_env_value('FIRST_TIME_START', 'TRUE')
+                else:
+                    current_value = self.config_manager.get_env_value('FIRST_TIME_START', 'TRUE')
+                    if current_value.upper() != 'FALSE':
+                        self.config_manager.set_env_value('FIRST_TIME_START', 'FALSE')
+            except Exception as e:
+                self.logger.error(f"Error checking CSPR files: {str(e)}")
+                # Keep the path even on error
+                self.logger.info(f"Keeping database path despite error: {current_db_path}")
+        # Set first time startup flag
         self.is_first_time_startup = self.config_manager.get_env_value('FIRST_TIME_START', 'TRUE').upper() == 'TRUE'
+        # Initialize database manager after potential path reset
         self._init_db_manager()
+        # Only preload essential controllers after determining startup state
+        self._preload_essential_controllers()
+        # Start background loading of commonly used modules
+        self._background_load_common_modules()
         # Defer theme initialization
         self._init_theme_settings()
     def validate_db_path(self, path):
         """Validate the given database path"""
+        print("path", path)
+        print("db.manager validate_db_path", self.db_manager.validate_db_path(path))
         return self.db_manager.validate_db_path(path)
     def save_db_path(self, path):
     def _get_window_class(self, window_name):
         """Get the controller class with optimized loading"""
         try:
             # Check if module is already cached
             module_path = f"controllers.{window_name}Controller"
             if module_path in self._module_cache:
             if not hasattr(controller_module, class_name):
                 raise AttributeError(f"Controller module does not contain class {class_name}")
             return getattr(controller_module, class_name)
         except Exception as e:
             self.logger.error(f"Error creating window {window_name}: {str(e)}")
             raise
+    def get_startup_window(self, keep_db_path=False):
+        """
+        Creates and returns a new startup window controller
+        Args:
+            keep_db_path (bool): If True, keeps the existing DB path when initializing startup
+        """
+        from controllers.StartupWindowController import StartupWindowController
+        return StartupWindowController(self, keep_db_path=keep_db_path)
     def get_home_window(self):
         """Get or create home window with proper initialization"""
     def _background_load_common_modules(self):
         """Start background loading of commonly used modules"""
         try:
+            common_modules = [
+                "MultitargetingWindow",
+                "PopulationAnalysisWindow",
+                "NewGenomeWindow",
+                "NewEndonuclease",
+                "NCBIWindow"
+            ]
             for module_name in common_modules:
                 if (module_name not in self._module_cache and
                     module_name not in self._preloading_modules):
                 preloader = self._preloading_modules[module_name]
                 if not preloader.isRunning():  # Only remove if thread is finished
                     del self._preloading_modules[module_name]
         except Exception as e:
             self.logger.error(f"Error handling preloaded module: {str(e)}")
     def set_current_annotation_file(self, annotation_file):
         """Set the current annotation file and notify listeners"""
         try:
             if self._current_annotation_file != annotation_file:
                 self._current_annotation_file = annotation_file
                 self.annotation_file_changed.emit(annotation_file)
         except Exception as e:
             self.logger.error(f"Error setting current annotation file: {str(e)}")
     def get_current_annotation_file(self):
         """Get the currently selected annotation file"""
+        return self._current_annotation_file
     def get_scoring_options_window(self, view_targets_controller):
         """Create and return ScoringOptionsController instance"""
             self.logger.error(f"Error adjusting path: {str(e)}")
             return path  # Return original path if adjustment fails
+    def get_stylesheet(self):
+        """Get the current theme's stylesheet"""
+        current_theme = self.get_theme()
+        return self.get_dark_stylesheet() if current_theme == "dark" else self.get_light_stylesheet()
+    def get_dark_stylesheet(self):
+        """Get dark theme stylesheet"""
+        theme = {
+            "bg_color": "#2b2b2b",
+            "fg_color": "#ffffff",
+            "button_bg_color": "#3a3a3a",
+            "button_border_color": "#5a5a5a",
+            "button_hover_bg_color": "#4a4a4a",
+            "input_bg_color": "#3a3a3a",
+            "input_border_color": "#5a5a5a",
+            "progress_bar_bg": "#3a3a3a",
+            "progress_bar_chunk": "#51b85e"
+        }
+        return self._get_themed_stylesheet(theme)
+    def get_light_stylesheet(self):
+        """Get light theme stylesheet"""
+        theme = {
+            "bg_color": "#f0f0f0",
+            "fg_color": "#000000",
+            "button_bg_color": "#e0e0e0",
+            "button_border_color": "#c0c0c0",
+            "button_hover_bg_color": "#d0d0d0",
+            "input_bg_color": "#ffffff",
+            "input_border_color": "#c0c0c0",
+            "progress_bar_bg": "#e0e0e0",
+            "progress_bar_chunk": "#51b85e"
+        }
+        return self._get_themed_stylesheet(theme)
+    def _get_themed_stylesheet(self, theme):
+        """Generate stylesheet based on theme colors"""
+        return f"""
+            QMainWindow, QWidget {{
+                background-color: {theme['bg_color']};
+                color: {theme['fg_color']};
+            }}
+            QPushButton {{
+                background-color: {theme['button_bg_color']};
+                border: 1px solid {theme['button_border_color']};
+                padding: 5px;
+                min-width: 80px;
+            }}
+            QPushButton:hover {{
+                background-color: {theme['button_hover_bg_color']};
+            }}
+            QLineEdit {{
+                background-color: {theme['input_bg_color']};
+                border: 1px solid {theme['input_border_color']};
+                padding: 5px;
+            }}
+            QComboBox {{
+                background-color: {theme['input_bg_color']};
+                border: 1px solid {theme['input_border_color']};
+                padding: 5px;
+            }}
+            QComboBox:hover {{
+                background-color: {theme['button_hover_bg_color']};
+            }}
+            QRadioButton {{
+                color: {theme['fg_color']};
+            }}
+            QProgressBar {{
+                border: 1px solid {theme['button_border_color']};
+                background-color: {theme['progress_bar_bg']};
+                text-align: center;
+            }}
+            QProgressBar::chunk {{
+                background-color: {theme['progress_bar_chunk']};
+            }}
+            QGroupBox {{
+                border: 1px solid {theme['button_border_color']};
+                margin-top: 0.5em;
+                padding-top: 0.5em;
+            }}
+            QGroupBox::title {{
+                color: {theme['fg_color']};
+                subcontrol-origin: margin;
+                left: 10px;
+                padding: 0 3px 0 3px;
+            }}
+            QDoubleSpinBox {{
+                background-color: {theme['input_bg_color']};
+                border: 1px solid {theme['input_border_color']};
+                padding: 5px;
+            }}
+        """
+    def get_organism_files(self):
+        """Get mapping of organisms to their files from database manager"""
+        organism_files, _ = self.db_manager.get_organisms_and_endos()
+        return organism_files
+    def get_groupbox_style(self) -> str:
+        """Get the standardized groupbox style with green accent color"""
+        return """
+        QGroupBox:title {
+            subcontrol-origin: margin;
+            left: 10px;
+            padding: 0 5px 0 5px;
+        }
+        QGroupBox {
+            border: 2px solid rgb(111,181,110);
+            border-radius: 9px;
+            margin-top: 10px;
+            font: bold 14pt 'Arial';
+        }
+        QGroupBox#grpNavigationMenu {
+            border: 2px dashed rgb(88,89,91);
+            border-radius: 9px;
+            margin-top: 10px;
+            font: bold 14pt 'Arial';
+        }
+        """
 # Global instance
 global_settings = None

src/models/HomeWindowModel.py CHANGED Viewed

@@ -5,15 +5,16 @@ from utils.ui import show_error
 from models.DatabaseManager import FileChangeType
 class HomeWindowModel:
-    def __init__(self, global_settings):
         self.global_settings = global_settings
         self.logger = global_settings.get_logger()
-        self.data = {
-            'organism_to_files': {},
-            'organism_to_endonuclease': {},
-            'annotation_files': set()  # Using set for efficient updates
-        }
-        self.load_data()
     def load_data(self) -> None:
         """Load all required data"""
@@ -56,8 +57,8 @@ class HomeWindowModel:
         """Load organism and endonuclease data from CSPR files"""
         try:
             # Clear existing data
-            self.data["organism_to_files"] = {}
-            self.data["organism_to_endonuclease"] = {}
             cspr_files = glob.glob(os.path.join(self.global_settings.get_db_path(), "*.cspr"))
@@ -70,20 +71,20 @@ class HomeWindowModel:
                     organism = f.readline().strip().replace("GENOME: ", '')
                 # Update organism to files mapping
-                if organism not in self.data["organism_to_files"]:
-                    self.data["organism_to_files"][organism] = {}
-                self.data["organism_to_files"][organism][endonuclease] = [
                     file_name,
                     file_name.replace(".cspr", "_repeats.db")
                 ]
                 # Update organism to endonuclease mapping
-                if organism not in self.data["organism_to_endonuclease"]:
-                    self.data["organism_to_endonuclease"][organism] = []
-                if endonuclease not in self.data["organism_to_endonuclease"][organism]:
-                    self.data["organism_to_endonuclease"][organism].append(endonuclease)
-            self.logger.debug(f"Loaded data for {len(self.data['organism_to_files'])} organisms")
         except Exception as e:
             self.logger.error(f"Error loading organisms and endonucleases: {str(e)}")
@@ -99,12 +100,12 @@ class HomeWindowModel:
             )
             # Process files
-            self.data["annotation_files"] = {
                 os.path.basename(file) for file in annotation_files
                 if not file.endswith('.index')  # Exclude index files
             }
-            self.logger.debug(f"Loaded {len(self.data['annotation_files'])} annotation files")
         except Exception as e:
             self.logger.error(f"Error loading annotation files: {str(e)}")
@@ -112,15 +113,15 @@ class HomeWindowModel:
     def get_organism_to_files(self) -> Dict[str, Dict[str, List[str]]]:
         """Get mapping of organisms to their files"""
-        return self.data['organism_to_files']
     def get_organism_to_endonuclease(self) -> Dict[str, List[str]]:
         """Get mapping of organisms to their endonucleases"""
-        return self.data.get("organism_to_endonuclease", {})
     def get_annotation_files(self) -> List[str]:
         """Get list of annotation files"""
-        return sorted(self.data.get("annotation_files", set()), key=str.lower)
     def find_targets(self, input_data: dict) -> None:
         pass

 from models.DatabaseManager import FileChangeType
 class HomeWindowModel:
+    def __init__(self, global_settings, skip_initial_load=False):
         self.global_settings = global_settings
         self.logger = global_settings.get_logger()
+        self._organism_to_files = {}
+        self._organism_to_endonuclease = {}
+        self._annotation_files = []
+        # Only load data if not skipped
+        if not skip_initial_load:
+            self.load_data()
     def load_data(self) -> None:
         """Load all required data"""
         """Load organism and endonuclease data from CSPR files"""
         try:
             # Clear existing data
+            self._organism_to_files = {}
+            self._organism_to_endonuclease = {}
             cspr_files = glob.glob(os.path.join(self.global_settings.get_db_path(), "*.cspr"))
                     organism = f.readline().strip().replace("GENOME: ", '')
                 # Update organism to files mapping
+                if organism not in self._organism_to_files:
+                    self._organism_to_files[organism] = {}
+                self._organism_to_files[organism][endonuclease] = [
                     file_name,
                     file_name.replace(".cspr", "_repeats.db")
                 ]
                 # Update organism to endonuclease mapping
+                if organism not in self._organism_to_endonuclease:
+                    self._organism_to_endonuclease[organism] = []
+                if endonuclease not in self._organism_to_endonuclease[organism]:
+                    self._organism_to_endonuclease[organism].append(endonuclease)
+            self.logger.debug(f"Loaded data for {len(self._organism_to_files)} organisms")
         except Exception as e:
             self.logger.error(f"Error loading organisms and endonucleases: {str(e)}")
             )
             # Process files
+            self._annotation_files = {
                 os.path.basename(file) for file in annotation_files
                 if not file.endswith('.index')  # Exclude index files
             }
+            self.logger.debug(f"Loaded {len(self._annotation_files)} annotation files")
         except Exception as e:
             self.logger.error(f"Error loading annotation files: {str(e)}")
     def get_organism_to_files(self) -> Dict[str, Dict[str, List[str]]]:
         """Get mapping of organisms to their files"""
+        return self._organism_to_files
     def get_organism_to_endonuclease(self) -> Dict[str, List[str]]:
         """Get mapping of organisms to their endonucleases"""
+        return self._organism_to_endonuclease
     def get_annotation_files(self) -> List[str]:
         """Get list of annotation files"""
+        return sorted(self._annotation_files, key=str.lower)
     def find_targets(self, input_data: dict) -> None:
         pass

src/models/NCBIWindowModel.py CHANGED Viewed

@@ -8,6 +8,7 @@ import os
 import platform
 import requests
 from urllib.parse import urlparse
 class NCBIWindowModel:
     class DownloadThread(QtCore.QThread):
@@ -26,7 +27,8 @@ class NCBIWindowModel:
             self.download_fna = download_fna
             self.download_gbff = download_gbff
             self.logger = controller.settings.get_logger()
-            self.db_path = controller.settings.get_db_path()
         def run(self):
             try:
@@ -54,7 +56,7 @@ class NCBIWindowModel:
                 file_type = 'FNA' if is_fna else 'GBFF'
                 extension = '.gz' if is_gzipped else ''
-                # Create output directory using the current database path
                 output_dir = os.path.join(self.db_path, file_type)
                 os.makedirs(output_dir, exist_ok=True)
@@ -129,6 +131,7 @@ class NCBIWindowModel:
                 file_type = 'FNA' if is_fna else 'GBFF'
                 extension = '.gz' if is_gzipped else ''
                 local_filename = os.path.join(
                     self.db_path,
                     file_type,
@@ -185,6 +188,9 @@ class NCBIWindowModel:
                 self.controller.model.add_downloaded_file(decompressed_filename)
     def __init__(self, settings):
         self.settings = settings
         self.logger = settings.get_logger()
         self.df = pd.DataFrame()
@@ -202,6 +208,8 @@ class NCBIWindowModel:
             "ENA (European Nucleotide Archive)": self._search_ena,
             "UCSC Genome Browser": self._search_ucsc
         }
     def search_ncbi(self, search_params):
         """Search selected database with given parameters"""
@@ -628,9 +636,20 @@ class NCBIWindowModel:
             raise
     def get_output_path(self, file_type):
-        db_path = self.settings.get_db_path()
         self.logger.debug(f"Using database path for downloads: {db_path}")
-        return os.path.join(db_path, file_type)
     def rename_file(self, old_name, new_name, file_type):
         old_path = os.path.join(self.get_output_path(file_type), old_name)

 import platform
 import requests
 from urllib.parse import urlparse
+import time
 class NCBIWindowModel:
     class DownloadThread(QtCore.QThread):
             self.download_fna = download_fna
             self.download_gbff = download_gbff
             self.logger = controller.settings.get_logger()
+            self.db_path = controller.settings.db_manager.get_active_db_path()
+            self.logger.debug(f"Using database path for downloads: {self.db_path}")
         def run(self):
             try:
                 file_type = 'FNA' if is_fna else 'GBFF'
                 extension = '.gz' if is_gzipped else ''
+                # Create output directory using the active database path
                 output_dir = os.path.join(self.db_path, file_type)
                 os.makedirs(output_dir, exist_ok=True)
                 file_type = 'FNA' if is_fna else 'GBFF'
                 extension = '.gz' if is_gzipped else ''
+                # Use the active database path for FTP downloads as well
                 local_filename = os.path.join(
                     self.db_path,
                     file_type,
                 self.controller.model.add_downloaded_file(decompressed_filename)
     def __init__(self, settings):
+        start_time = time.time()
+        settings.logger.debug("Starting NCBIWindowModel initialization")
         self.settings = settings
         self.logger = settings.get_logger()
         self.df = pd.DataFrame()
             "ENA (European Nucleotide Archive)": self._search_ena,
             "UCSC Genome Browser": self._search_ucsc
         }
+        self.logger.debug(f"NCBIWindowModel initialization took: {time.time() - start_time:.2f} seconds")
     def search_ncbi(self, search_params):
         """Search selected database with given parameters"""
             raise
     def get_output_path(self, file_type):
+        """Get the appropriate output path for downloads"""
+        # Use the active database path which includes pending path during new genome analysis
+        db_path = self.settings.db_manager.get_active_db_path()
         self.logger.debug(f"Using database path for downloads: {db_path}")
+        output_path = os.path.join(db_path, file_type)
+        # Ensure the directory exists
+        os.makedirs(output_path, exist_ok=True)
+        return output_path
+    def cancel_pending_path(self):
+        """Cancel any pending path changes"""
+        if self.settings.db_manager.pending_db_path:
+            self.logger.info("Cancelling pending database path change")
+            self.settings.db_manager.pending_db_path = None
     def rename_file(self, old_name, new_name, file_type):
         old_path = os.path.join(self.get_output_path(file_type), old_name)

src/models/NewGenomeWindowModel.py CHANGED Viewed

@@ -64,13 +64,13 @@ class NewGenomeWindowModel(QObject):
         return False
     def create_arguments_command_for_job(self, organism_name, strain, organism_code, file_path, endonuclease_data, multithreading_checked, generate_repeats_checked):
-        db_path = self.settings.get_db_path()
         # Ensure db_path ends with a forward slash
         if not db_path.endswith('/'):
             db_path = f"{db_path}/"
-        self.logger.debug(f"Using database path: {db_path}")  # Add logging
         print(f"The endonuclease data is {endonuclease_data}")

         return False
     def create_arguments_command_for_job(self, organism_name, strain, organism_code, file_path, endonuclease_data, multithreading_checked, generate_repeats_checked):
+        db_path = self.settings.db_manager.get_active_db_path()
         # Ensure db_path ends with a forward slash
         if not db_path.endswith('/'):
             db_path = f"{db_path}/"
+        self.logger.debug(f"Using database path for job processing: {db_path}")  # Add logging
         print(f"The endonuclease data is {endonuclease_data}")

src/models/OffTarget/local_output.txt CHANGED Viewed

@@ -1,29 +1 @@
-DETAILED OUTPUT
-CACTTATGACCGGGCAACTT:0.000000
-ACACTTATGACCGGGCAACT:0.080598
-0.080598,1,-100695,ACAATTACGCCCGGGCAACC
-TCAAAATAGCCCAAGTTGCC:0.000000
-ATTTTGCTACACTTATGACC:0.000000
-AATTTTGCTACACTTATGAC:0.000000
-GGGAATACTCCCTTTTATTG:0.000000
-GCAAAATTATCCTCAATAAA:0.018309
-0.018309,1,1937923,GCAAAGTTTTCCTCAATATT
-CAAAATTATCCTCAATAAAA:0.107086
-0.059761,1,2361124,CACATTTACCCTCAATGAAA
-0.154411,1,4041223,CAAATCTATACTGAATAAAA
-CAGCTACAACCCGTGGCGGA:0.000000
-CCAGCTACAACCCGTGGCGG:0.106259
-0.106259,1,4257161,ACAACTGCAAGCCGTGGCGG
-CCGCCAGCTACAACCCGTGG:0.000000
-AGGGAGTATTCCCTCCGCCA:0.000000
-GACCCGCCAGCTACAACCCG:0.000000
-GGGAGTATTCCCTCCGCCAC:0.000000
-CCTCCGCCACGGGTTGTAGC:0.129554
-0.129554,1,-165804,GTTACGCCACGGGTTGTAGA
-CCGCCACGGGTTGTAGCTGG:0.000000
-CGCCACGGGTTGTAGCTGGC:0.000000
-GGACTACCAACGTTCACCAC:0.221431
-0.234722,1,-469831,TCGCTACCATCGTTCACCAC
-0.208141,1,2847166,GGAGAACCGACGGTCACCAC
-AGATAGTGTTCGTAATCCAG:0.000000
-CGTAATCCAGTGGTGAACGT:0.000000


1	+ AVG OUTPUT

src/models/OffTargetModel.py CHANGED Viewed

@@ -105,6 +105,7 @@ class OffTargetModel(QObject):
             self.logger.debug(f"Max mismatches: {parameters['max_mismatches']}")
             self.logger.debug(f"Tolerance: {parameters['tolerance']}")
             self.logger.debug(f"Average output: {parameters['average_output']}")
             # Set working directory
             off_target_dir = self.global_settings.get_off_target_dir_path()
@@ -129,30 +130,8 @@ class OffTargetModel(QObject):
             self.logger.debug("Starting QProcess with command:")
             self.logger.debug(cmd)
-            example_cmd = [
-                "/Users/admin/Documents/proj/CASPERtest/CASPERapp/src/models/OffTarget/temp.txt",
-                "spCas9",
-                "/Users/admin/Documents/CASPERdb2/eck_12_spCas9.cspr",
-                "/Users/admin/Documents/CASPERdb2/eck_12_spCas9_repeats.db",
-                "/Users/admin/Documents/CASPERdb2/testtttt",
-                "/Users/admin/Documents/proj/CASPERtest/CASPERapp/config/CASPERinfo",
-                "4",
-                "0.05",
-                "FALSE",
-                "TRUE",
-                "MATRIX:HSU MATRIX-spCas9-2013"
-            ]
-            print(f"cmd: {cmd}")
-            print(f"example_cmd: {example_cmd}")
             self.process.start(str(program_path), cmd)
             return True
         except Exception as e:
@@ -331,6 +310,21 @@ class OffTargetModel(QObject):
             casper_info_path = f'{self.global_settings.get_casper_info_path()}'
             endo = f'{parameters["endonuclease"]}'
             # Build command exactly as in old version
             cmd_parts = [
                 temp_path,
@@ -343,7 +337,8 @@ class OffTargetModel(QObject):
                 str(parameters['tolerance']),
                 'FALSE' if parameters['average_output'] else 'TRUE',
                 'TRUE' if parameters['average_output'] else 'FALSE',
-                f'{self._get_hsu_value(parameters)}'
             ]
             return program_path, cmd_parts

             self.logger.debug(f"Max mismatches: {parameters['max_mismatches']}")
             self.logger.debug(f"Tolerance: {parameters['tolerance']}")
             self.logger.debug(f"Average output: {parameters['average_output']}")
+            self.logger.debug(f"Annotation file: {self.global_settings.get_current_annotation_file()}")
             # Set working directory
             off_target_dir = self.global_settings.get_off_target_dir_path()
             self.logger.debug("Starting QProcess with command:")
             self.logger.debug(cmd)
             self.process.start(str(program_path), cmd)
             return True
         except Exception as e:
             casper_info_path = f'{self.global_settings.get_casper_info_path()}'
             endo = f'{parameters["endonuclease"]}'
+            # Get annotation file path
+            annotation_file = self.global_settings.get_current_annotation_file()
+            if not annotation_file:
+                raise ValueError("No annotation file selected")
+            # Build full annotation path and verify it exists
+            annotation_path = os.path.join(self.global_settings.get_db_path(), 'GBFF', annotation_file)
+            if not os.path.isfile(annotation_path):
+                # Try without GBFF subdirectory
+                annotation_path = os.path.join(self.global_settings.get_db_path(), annotation_file)
+                if not os.path.isfile(annotation_path):
+                    raise ValueError(f"Annotation file not found at {annotation_path}")
+            self.logger.debug(f"Using annotation file: {annotation_path}")
             # Build command exactly as in old version
             cmd_parts = [
                 temp_path,
                 str(parameters['tolerance']),
                 'FALSE' if parameters['average_output'] else 'TRUE',
                 'TRUE' if parameters['average_output'] else 'FALSE',
+                f'{self._get_hsu_value(parameters)}',
+                annotation_path  # Add annotation file path
             ]
             return program_path, cmd_parts

src/models/PopulationAnalysisWindowModel.py CHANGED Viewed

@@ -19,11 +19,8 @@ class PopulationAnalysisWindowModel:
     def load_endonucleases(self):
         """Load endonucleases from GlobalSettings"""
         try:
-            self.logger.info("Starting load_endonucleases()")
             # Get endonucleases from global settings
             endos = self.settings.get_endonucleases()
-            self.logger.debug(f"Raw endonucleases from settings: {endos}")
             if not endos:
                 self.logger.warning("No endonucleases returned from settings")
@@ -32,7 +29,6 @@ class PopulationAnalysisWindowModel:
             # Format the endonucleases for display
             formatted_endos = {}
             for endo, data in endos.items():
-                self.logger.debug(f"Processing endo: {endo}, data: {data}")
                 pam = data.get('pam', '').strip()
                 # Remove any extra "PAM:" text that might be in the PAM string
                 pam = pam.replace('PAM:', '').strip()
@@ -44,7 +40,6 @@ class PopulationAnalysisWindowModel:
                                               data.get('default_seed_length', ''),
                                               data.get('default_three_length', ''))
-            self.logger.info(f"Successfully formatted {len(formatted_endos)} endonucleases")
             self.logger.debug(f"Formatted endonucleases: {formatted_endos}")
             return formatted_endos

     def load_endonucleases(self):
         """Load endonucleases from GlobalSettings"""
         try:
             # Get endonucleases from global settings
             endos = self.settings.get_endonucleases()
             if not endos:
                 self.logger.warning("No endonucleases returned from settings")
             # Format the endonucleases for display
             formatted_endos = {}
             for endo, data in endos.items():
                 pam = data.get('pam', '').strip()
                 # Remove any extra "PAM:" text that might be in the PAM string
                 pam = pam.replace('PAM:', '').strip()
                                               data.get('default_seed_length', ''),
                                               data.get('default_three_length', ''))
             self.logger.debug(f"Formatted endonucleases: {formatted_endos}")
             return formatted_endos

src/models/StartupWindowModel.py CHANGED Viewed

@@ -2,6 +2,7 @@ from PyQt6.QtCore import QObject, pyqtSignal
 class StartupWindowModel(QObject):
     db_state_updated = pyqtSignal(bool, str, list)
     def __init__(self, global_settings):
         super().__init__()
@@ -12,16 +13,32 @@ class StartupWindowModel(QObject):
         self.settings.db_manager.db_state_changed.connect(self.on_db_state_updated)
     def get_db_path(self):
         return self.settings.get_db_path()
-    def save_db_path(self, directory_path):
-        """Save the database path and trigger validation"""
-        self.logger.debug(f"Saving database path: {directory_path}")
-        # The db_manager will emit its own signals that we're now listening to
-        success, message = self.settings.save_db_path(directory_path)
-        return success, message
     def on_db_state_updated(self, is_valid, message, cspr_files):
         """Handle database state updates"""
-        self.logger.debug(f"StartupWindowModel received db state update: valid={is_valid}, message={message}, cspr_files_count={len(cspr_files)}")
         self.db_state_updated.emit(is_valid, message, cspr_files)

 class StartupWindowModel(QObject):
     db_state_updated = pyqtSignal(bool, str, list)
+    _is_saving = False  # Add flag to prevent recursion
     def __init__(self, global_settings):
         super().__init__()
         self.settings.db_manager.db_state_changed.connect(self.on_db_state_updated)
     def get_db_path(self):
+        """Get the current database path without modifying it"""
         return self.settings.get_db_path()
+    def save_db_path(self, path):
+        """Save the database path"""
+        try:
+            if self._is_saving:  # Prevent recursive saves
+                return
+            self._is_saving = True
+            try:
+                # Don't clear the path if it's invalid - let the controller handle that
+                self.settings.save_db_path(path)
+                self.settings.update_db_state()
+            finally:
+                self._is_saving = False
+        except Exception as e:
+            self._is_saving = False
+            self.logger.error(f"Error saving database path: {str(e)}")
+            raise
     def on_db_state_updated(self, is_valid, message, cspr_files):
         """Handle database state updates"""
+        if self._is_saving:  # Don't emit signals during save operation
+            return
+        self.logger.debug(f"StartupWindowModel received db state update: valid={is_valid}, message={message}")
         self.db_state_updated.emit(is_valid, message, cspr_files)

src/models/ViewTargetsModel.py CHANGED Viewed

@@ -1,88 +1,67 @@
 from models.CSPRparser import CSPRparser
-from models.HomeWindowModel import HomeWindowModel
-from models.AnnotationParser import AnnotationParser
-import os
 from Bio import SeqIO
 from collections import defaultdict
 import traceback
-class ViewTargetsModel(HomeWindowModel):
     def __init__(self, global_settings):
         super().__init__(global_settings)
         self.guides = []
         self.cspr_parser = None
-        self.annotation_parser = None
         self.gene_sequence = ""
         self.highlighted_sequence = ""
         self.gene_info = {}
         self.available_genes = []
         self.filter_options = {}
         self.scoring_options = {}
-        self.annotation_path = ""
         self.current_gene_start = 0
         self.current_gene_end = 0
         self.extended_sequence = ""
         self.chromosome = ""
         self._gene_data_cache = {}
         self._sequence_cache = {}
         self._parser_cache = {}
         self._chromosome_seqs = {}
         self._cached_guides = {}
-        self.global_settings.annotation_file_changed.connect(self._on_annotation_file_changed)
-        # Initialize annotation path
-        self.annotation_path = os.path.join(
-            self.global_settings.get_db_path(),
-            'GBFF',
-            self.global_settings.get_current_annotation_file()
-        )
-        self.logger.debug(f"Initialized annotation path: {self.annotation_path}")
-    def cleanup(self):
-        """Cleanup method to be called when the view is closed"""
-        try:
-            # Disconnect from annotation file changes
-            if hasattr(self, '_annotation_signal'):
-                self.global_settings.annotation_file_changed.disconnect(self._on_annotation_file_changed)
-                self.global_settings.logger.debug("ViewTargetsModel disconnected from annotation file changes")
-            self._gene_data_cache.clear()
-            self._sequence_cache.clear()
-            self._parser_cache.clear()
-        except Exception as e:
-            self.global_settings.logger.error(f"Error in ViewTargetsModel cleanup: {str(e)}")
-    def _on_annotation_file_changed(self, new_annotation_file):
-        """Clear all caches when annotation file changes"""
-        try:
-            self.logger.debug(f"ViewTargetsModel clearing caches for new annotation file: {new_annotation_file}")
-            self._gene_data_cache.clear()
-            self._sequence_cache.clear()
-            self._parser_cache.clear()
-            # Update annotation path and parser
-            self.annotation_path = os.path.join(self.global_settings.get_db_path(), 'GBFF', new_annotation_file)
-            self.annotation_parser = AnnotationParser(self.global_settings)
-            self.annotation_parser.set_annotation_file(self.annotation_path)
-            # Clear other stored data
-            self.gene_sequence = ""
-            self.highlighted_sequence = ""
-            self.gene_info = {}
-            self.available_genes = []
-            self._chromosome_seqs = {}
-        except Exception as e:
-            self.logger.error(f"Error in _on_annotation_file_changed: {str(e)}")
     def load_guides(self, selected_targets, organism, endonuclease):
         """Load guides with proper error handling"""
         try:
-            self.logger.debug(f"Starting load_guides with {len(selected_targets)} targets")
             self.organism = organism
             self.endonuclease = endonuclease
@@ -92,7 +71,7 @@ class ViewTargetsModel(HomeWindowModel):
                 self.cspr_parser = self._parser_cache[cspr_key]
                 self.logger.debug("Using cached CSPR parser")
             else:
-                org_files = self.get_organism_to_files()
                 if organism not in org_files or endonuclease not in org_files[organism]:
                     self.logger.error(f"No CSPR file found for {organism} and {endonuclease}")
                     return
@@ -101,7 +80,6 @@ class ViewTargetsModel(HomeWindowModel):
                 cspr_path = os.path.join(self.global_settings.get_db_path(), cspr_file)
                 self.cspr_parser = CSPRparser(cspr_path, self.global_settings.get_casper_info_path())
                 self._parser_cache[cspr_key] = self.cspr_parser
-                self.logger.debug("Created new CSPR parser")
             # Initialize guides and genes
             self.guides = []
@@ -156,8 +134,6 @@ class ViewTargetsModel(HomeWindowModel):
             self.guides = list(unique_guides.values())
             self.logger.debug(f"Found {len(self.guides)} unique guides")
-            self.logger.debug(f"Available genes: {self.available_genes}")
         except Exception as e:
             self.logger.error(f"Error in load_guides: {str(e)}")
             self.logger.error(f"Stack trace: {traceback.format_exc()}")
@@ -174,13 +150,6 @@ class ViewTargetsModel(HomeWindowModel):
         return self._chromosome_seqs.get(chromosome)
-    def _initialize_annotation_parser(self):
-        """Initialize annotation parser if not already initialized"""
-        if self.annotation_parser is None:
-            self.annotation_parser = AnnotationParser(self.global_settings)
-            if self.annotation_path:
-                self.annotation_parser.set_annotation_file(self.annotation_path)
     def get_gene_data(self, locus_tag):
         """Get gene data with proper error handling"""
         try:
@@ -192,25 +161,19 @@ class ViewTargetsModel(HomeWindowModel):
             if locus_tag in self._gene_data_cache:
                 return self._gene_data_cache[locus_tag]
-            # Initialize annotation parser if not already done
-            if not hasattr(self, 'annotation_parser') or self.annotation_parser is None:
-                self.annotation_parser = AnnotationParser(self.global_settings)
-                annotation_file = self.global_settings.get_current_annotation_file()
-                annotation_path = os.path.join(self.global_settings.get_db_path(), 'GBFF', annotation_file)
-                self.annotation_parser.set_annotation_file(annotation_path)
-                self.logger.debug(f"Initialized annotation parser with file: {annotation_path}")
             # Get gene data from parser with proper string conversion
             gene_data = None
             if isinstance(locus_tag, (str, int)):
                 locus_tag_str = str(locus_tag).strip()
-                self.logger.debug(f"Searching for locus tag: {locus_tag_str}")
                 # Look up by locus tag directly
                 gene_data = self.annotation_parser.get_gene_data(locus_tag_str.lower())
             if gene_data:
                 self._gene_data_cache[locus_tag] = gene_data
-                self.logger.debug(f"Found gene data: {gene_data.keys()}")
             else:
                 self.logger.debug(f"No gene data found for locus tag: {locus_tag}")
@@ -244,7 +207,6 @@ class ViewTargetsModel(HomeWindowModel):
             self.logger.debug(f"View exons only is: {getattr(self, '_view_exons_only', False)}")
             # Regular gene-based search
-            self.logger.debug(f"Getting gene data for locus tag: {identifier}")
             gene_data = self.get_gene_data(identifier)
             if not gene_data or 'info' not in gene_data:
                 self.logger.warning(f"No gene data found for locus tag: {identifier}")
@@ -255,53 +217,75 @@ class ViewTargetsModel(HomeWindowModel):
                 print(f"gene_data: {gene_data}")
                 full_location = gene_data['info'].get('full_location', '')
                 print(f"Full location: {full_location}")
-                if full_location and ',' in full_location:  # Multiple exons
-                    self.logger.debug(f"Processing exons from full location: {full_location}")
-                    exon_sequences = []
-                    full_sequence = gene_data['sequence']  # Use sequence from gene_data
-                    # Calculate padding offset
-                    padding = 30
-                    gene_start = gene_data['info']['start']
-                    padded_start = max(0, gene_start - padding)
-                    padding_offset = gene_start - padded_start
-                    print(f"gene_start: {gene_start}, padded_start: {padded_start}, padding_offset: {padding_offset}")
-                    # Process each exon location
-                    for exon in full_location.split(','):
-                        # Extract coordinates and strand
-                        coords = exon.split('(')[0]  # Get part before strand
-                        strand = exon.split('(')[1][0]  # Get + or - from (+ or (-
-                        start, end = map(int, coords.split('..'))
-                        print(f"coords: {coords}, strand: {strand}, start: {start}, end: {end}")
-                        # Adjust coordinates relative to gene start and account for padding
-                        relative_start = start - gene_start + padding_offset
-                        relative_end = end - gene_start + padding_offset
-                        print(f"relative_start: {relative_start}, relative_end: {relative_end}")
-                        # Get exon sequence from the padded sequence
-                        exon_seq = full_sequence[relative_start:relative_end]
-                        exon_sequences.append(exon_seq)
-                    # Join exon sequences
-                    sequence = ''.join(exon_sequences)
-                    self.logger.debug(f"Created concatenated exon sequence of length: {len(sequence)}")
-                    return {
-                        'sequence': sequence,
-                        'info': gene_data['info'],
-                        'start': gene_data['info']['start'],
-                        'end': gene_data['info']['end']
-                    }
             # If not in exons-only mode or no exons to process, return normal sequence
             if 'sequence' in gene_data:
                 sequence = gene_data['sequence']
-                self.logger.debug(f"Got sequence of length: {len(sequence)}")
                 # Format sequence with padding in lowercase (only if not in exons-only mode)
                 if not hasattr(self, '_view_exons_only') or not self._view_exons_only:
@@ -328,8 +312,6 @@ class ViewTargetsModel(HomeWindowModel):
                     'end': gene_data['info']['end'],
                     'full_location': gene_data['info'].get('full_location', '')
                 }
-                self.logger.debug(f"Returning sequence of length: {len(formatted_sequence)}")
                 return result
             self.logger.warning(f"No sequence data found in gene_data for {identifier}")
@@ -343,27 +325,25 @@ class ViewTargetsModel(HomeWindowModel):
     def _get_sequence_for_position(self, chrom, start, end):
         """Get sequence for a given position with proper padding handling"""
         try:
-            if not hasattr(self, 'annotation_parser') or self.annotation_parser is None:
-                self.annotation_parser = AnnotationParser(self.global_settings)
-                annotation_file = self.global_settings.get_current_annotation_file()
-                annotation_path = os.path.join(self.global_settings.get_db_path(), 'GBFF', annotation_file)
-                self.annotation_parser.set_annotation_file(annotation_path)
             feature_info = {
                 'chromosome': chrom,  # Use raw chromosome ID directly
-                'start': start-1,  # Convert to 0-based indexing
                 'end': end
             }
             self.logger.debug(f"Getting sequence for feature info: {feature_info}")
-            sequence = self.annotation_parser._get_sequence_for_gene(feature_info)
             if sequence:
                 padding = 30
                 # Handle start position padding
-                if start == 1:
-                    # No padding at start if starting at position 1
                     five_prime_pad = ""
                     main_sequence = sequence[:-(padding if len(sequence) > padding else 0)].upper()
                 else:

 from models.CSPRparser import CSPRparser
+from models.BaseModel import BaseModel
 from Bio import SeqIO
 from collections import defaultdict
 import traceback
+import os
+class ViewTargetsModel(BaseModel):
     def __init__(self, global_settings):
         super().__init__(global_settings)
+        # Initialize model state
         self.guides = []
         self.cspr_parser = None
         self.gene_sequence = ""
         self.highlighted_sequence = ""
         self.gene_info = {}
         self.available_genes = []
         self.filter_options = {}
         self.scoring_options = {}
         self.current_gene_start = 0
         self.current_gene_end = 0
         self.extended_sequence = ""
         self.chromosome = ""
+        # Initialize caches
         self._gene_data_cache = {}
         self._sequence_cache = {}
         self._parser_cache = {}
         self._chromosome_seqs = {}
         self._cached_guides = {}
+    def _clear_caches(self):
+        """Clear all model-specific caches"""
+        self._gene_data_cache.clear()
+        self._sequence_cache.clear()
+        self._parser_cache.clear()
+        self._chromosome_seqs.clear()
+        self._cached_guides.clear()
+        # Clear other stored data
+        self.gene_sequence = ""
+        self.highlighted_sequence = ""
+        self.gene_info = {}
+        self.available_genes = []
+    def _ensure_annotation_parser(self) -> bool:
+        """Ensure annotation parser is initialized
+        Returns:
+            bool: True if parser is ready, False otherwise
+        """
+        if self.annotation_parser is None:
+            try:
+                self._initialize_annotation_parser()
+                return True
+            except Exception as e:
+                self.logger.error(f"Failed to initialize annotation parser: {str(e)}")
+                return False
+        return True
     def load_guides(self, selected_targets, organism, endonuclease):
         """Load guides with proper error handling"""
         try:
             self.organism = organism
             self.endonuclease = endonuclease
                 self.cspr_parser = self._parser_cache[cspr_key]
                 self.logger.debug("Using cached CSPR parser")
             else:
+                org_files = self.global_settings.get_organism_files()
                 if organism not in org_files or endonuclease not in org_files[organism]:
                     self.logger.error(f"No CSPR file found for {organism} and {endonuclease}")
                     return
                 cspr_path = os.path.join(self.global_settings.get_db_path(), cspr_file)
                 self.cspr_parser = CSPRparser(cspr_path, self.global_settings.get_casper_info_path())
                 self._parser_cache[cspr_key] = self.cspr_parser
             # Initialize guides and genes
             self.guides = []
             self.guides = list(unique_guides.values())
             self.logger.debug(f"Found {len(self.guides)} unique guides")
         except Exception as e:
             self.logger.error(f"Error in load_guides: {str(e)}")
             self.logger.error(f"Stack trace: {traceback.format_exc()}")
         return self._chromosome_seqs.get(chromosome)
     def get_gene_data(self, locus_tag):
         """Get gene data with proper error handling"""
         try:
             if locus_tag in self._gene_data_cache:
                 return self._gene_data_cache[locus_tag]
+            # Ensure parser is initialized
+            if not self._ensure_annotation_parser():
+                return None
             # Get gene data from parser with proper string conversion
             gene_data = None
             if isinstance(locus_tag, (str, int)):
                 locus_tag_str = str(locus_tag).strip()
                 # Look up by locus tag directly
                 gene_data = self.annotation_parser.get_gene_data(locus_tag_str.lower())
             if gene_data:
                 self._gene_data_cache[locus_tag] = gene_data
             else:
                 self.logger.debug(f"No gene data found for locus tag: {locus_tag}")
             self.logger.debug(f"View exons only is: {getattr(self, '_view_exons_only', False)}")
             # Regular gene-based search
             gene_data = self.get_gene_data(identifier)
             if not gene_data or 'info' not in gene_data:
                 self.logger.warning(f"No gene data found for locus tag: {identifier}")
                 print(f"gene_data: {gene_data}")
                 full_location = gene_data['info'].get('full_location', '')
                 print(f"Full location: {full_location}")
+                if full_location:
+                    if ',' in full_location:  # Multiple exons
+                        self.logger.debug(f"Processing exons from full location: {full_location}")
+                        exon_sequences = []
+                        full_sequence = gene_data['sequence']  # Use sequence from gene_data
+                        # Calculate padding offset
+                        padding = 30
+                        gene_start = gene_data['info']['start']
+                        padded_start = max(0, gene_start - padding)
+                        padding_offset = gene_start - padded_start
+                        print(f"gene_start: {gene_start}, padded_start: {padded_start}, padding_offset: {padding_offset}")
+                        # Process each exon location
+                        for exon in full_location.split(','):
+                            # Extract coordinates and strand
+                            coords = exon.split('(')[0]  # Get part before strand
+                            strand = exon.split('(')[1][0]  # Get + or - from (+ or (-
+                            start, end = map(int, coords.split('..'))
+                            print(f"coords: {coords}, strand: {strand}, start: {start}, end: {end}")
+                            # Adjust coordinates relative to gene start and account for padding
+                            relative_start = start - gene_start + padding_offset
+                            relative_end = end - gene_start + padding_offset
+                            print(f"relative_start: {relative_start}, relative_end: {relative_end}")
+                            # Get exon sequence from the padded sequence
+                            exon_seq = full_sequence[relative_start:relative_end]
+                            exon_sequences.append(exon_seq)
+                        # Join exon sequences
+                        sequence = ''.join(exon_sequences)
+                        self.logger.debug(f"Created concatenated exon sequence of length: {len(sequence)}")
+                        return {
+                            'sequence': sequence,
+                            'info': gene_data['info'],
+                            'start': gene_data['info']['start'],
+                            'end': gene_data['info']['end']
+                        }
+                    else:  # Single location/exon
+                        # Return sequence without padding for single exon
+                        sequence = gene_data['sequence']
+                        gene_start = gene_data['info']['start']
+                        gene_end = gene_data['info']['end']
+                        # Calculate padding offset
+                        padding = 30
+                        padded_start = max(0, gene_start - padding)
+                        padding_offset = gene_start - padded_start
+                        # Get sequence without padding
+                        relative_start = padding_offset
+                        relative_end = len(sequence) - padding_offset
+                        sequence = sequence[relative_start:relative_end]
+                        return {
+                            'sequence': sequence,
+                            'info': gene_data['info'],
+                            'start': gene_data['info']['start'],
+                            'end': gene_data['info']['end']
+                        }
             # If not in exons-only mode or no exons to process, return normal sequence
             if 'sequence' in gene_data:
                 sequence = gene_data['sequence']
                 # Format sequence with padding in lowercase (only if not in exons-only mode)
                 if not hasattr(self, '_view_exons_only') or not self._view_exons_only:
                     'end': gene_data['info']['end'],
                     'full_location': gene_data['info'].get('full_location', '')
                 }
                 return result
             self.logger.warning(f"No sequence data found in gene_data for {identifier}")
     def _get_sequence_for_position(self, chrom, start, end):
         """Get sequence for a given position with proper padding handling"""
         try:
+            if not self._ensure_annotation_parser():
+                return None
             feature_info = {
                 'chromosome': chrom,  # Use raw chromosome ID directly
+                'start': start,  # Keep as is since annotation parser handles 0-based conversion
                 'end': end
             }
             self.logger.debug(f"Getting sequence for feature info: {feature_info}")
+            # Use annotation parser's method directly
+            sequence = self.annotation_parser._get_sequence_for_position(chrom, start, end)
             if sequence:
                 padding = 30
                 # Handle start position padding
+                if start == 0:  # Already 0-based for sequence operations
+                    # No padding at start if starting at position 0
                     five_prime_pad = ""
                     main_sequence = sequence[:-(padding if len(sequence) > padding else 0)].upper()
                 else:

src/ui/find_targets.ui CHANGED Viewed

@@ -55,31 +55,6 @@
     </item>
     <item row="3" column="0" rowspan="2" colspan="2">
      <layout class="QHBoxLayout" name="horizontalLayout">
-      <item alignment="Qt::AlignLeft">
-       <widget class="QPushButton" name="pbtnBack">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
-        <property name="minimumSize">
-         <size>
-          <width>125</width>
-          <height>0</height>
-         </size>
-        </property>
-        <property name="maximumSize">
-         <size>
-          <width>16777215</width>
-          <height>16777215</height>
-         </size>
-        </property>
-        <property name="text">
-         <string>Return</string>
-        </property>
-       </widget>
-      </item>
       <item>
        <widget class="QPushButton" name="pbtnGenerateLibrary">
         <property name="sizePolicy">

     </item>
     <item row="3" column="0" rowspan="2" colspan="2">
      <layout class="QHBoxLayout" name="horizontalLayout">
       <item>
        <widget class="QPushButton" name="pbtnGenerateLibrary">
         <property name="sizePolicy">

src/ui/home_window.ui CHANGED Viewed

@@ -10,7 +10,7 @@
     <x>0</x>
     <y>0</y>
     <width>960</width>
-    <height>1147</height>
    </rect>
   </property>
   <property name="font">
@@ -50,7 +50,50 @@
     <string notr="true"/>
    </property>
    <layout class="QGridLayout" name="gridContainer">
-    <item row="4" column="0" rowspan="2" colspan="2">
      <layout class="QGridLayout" name="gridStep1Step2Step3">
       <property name="sizeConstraint">
        <enum>QLayout::SetDefaultConstraint</enum>
@@ -551,112 +594,6 @@
       </item>
      </layout>
     </item>
-    <item row="0" column="0">
-     <widget class="QLabel" name="lblWindowHeading">
-      <property name="sizePolicy">
-       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-        <horstretch>0</horstretch>
-        <verstretch>0</verstretch>
-       </sizepolicy>
-      </property>
-      <property name="minimumSize">
-       <size>
-        <width>0</width>
-        <height>0</height>
-       </size>
-      </property>
-      <property name="maximumSize">
-       <size>
-        <width>16777215</width>
-        <height>16777215</height>
-       </size>
-      </property>
-      <property name="font">
-       <font>
-        <family>Arial</family>
-        <pointsize>12</pointsize>
-        <weight>75</weight>
-        <italic>false</italic>
-        <bold>true</bold>
-       </font>
-      </property>
-      <property name="styleSheet">
-       <string notr="true"/>
-      </property>
-      <property name="text">
-       <string>CASPER</string>
-      </property>
-     </widget>
-    </item>
-    <item row="0" column="1">
-     <widget class="QLabel" name="pbtnThemeToggle">
-      <property name="minimumSize">
-       <size>
-        <width>50</width>
-        <height>0</height>
-       </size>
-      </property>
-      <property name="maximumSize">
-       <size>
-        <width>50</width>
-        <height>16777215</height>
-       </size>
-      </property>
-      <property name="text">
-       <string/>
-      </property>
-     </widget>
-    </item>
-    <item row="2" column="0" colspan="2">
-     <widget class="QGroupBox" name="grpNavigationMenu">
-      <property name="sizePolicy">
-       <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
-        <horstretch>0</horstretch>
-        <verstretch>0</verstretch>
-       </sizepolicy>
-      </property>
-      <property name="title">
-       <string>CASPER Navigation</string>
-      </property>
-      <layout class="QGridLayout" name="gridLayout_2">
-       <item row="1" column="1">
-        <widget class="QPushButton" name="pbtnPopulationAnalysis">
-         <property name="text">
-          <string>Population Analysis</string>
-         </property>
-        </widget>
-       </item>
-       <item row="0" column="1">
-        <widget class="QPushButton" name="pbtnNewEndonuclease">
-         <property name="text">
-          <string>Define New Endonuclease</string>
-         </property>
-        </widget>
-       </item>
-       <item row="1" column="0">
-        <widget class="QPushButton" name="pbtnMultitargetingAnalysis">
-         <property name="text">
-          <string>Multitargeting Analysis</string>
-         </property>
-        </widget>
-       </item>
-       <item row="2" column="0">
-        <widget class="QPushButton" name="pbtnCombineFiles">
-         <property name="text">
-          <string>Combine Files</string>
-         </property>
-        </widget>
-       </item>
-       <item row="0" column="0">
-        <widget class="QPushButton" name="pbtnNewGenome">
-         <property name="text">
-          <string>Analyze New Genome</string>
-         </property>
-        </widget>
-       </item>
-      </layout>
-     </widget>
-    </item>
    </layout>
   </widget>
   <action name="actionNew">

     <x>0</x>
     <y>0</y>
     <width>960</width>
+    <height>916</height>
    </rect>
   </property>
   <property name="font">
     <string notr="true"/>
    </property>
    <layout class="QGridLayout" name="gridContainer">
+    <item row="1" column="0" colspan="2">
+     <widget class="QGroupBox" name="grpNavigationMenu">
+      <property name="sizePolicy">
+       <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
+        <horstretch>0</horstretch>
+        <verstretch>0</verstretch>
+       </sizepolicy>
+      </property>
+      <property name="title">
+       <string>CASPER Navigation</string>
+      </property>
+      <layout class="QGridLayout" name="gridLayout_2">
+       <item row="1" column="1">
+        <widget class="QPushButton" name="pbtnPopulationAnalysis">
+         <property name="text">
+          <string>Population Analysis</string>
+         </property>
+        </widget>
+       </item>
+       <item row="0" column="1">
+        <widget class="QPushButton" name="pbtnNewEndonuclease">
+         <property name="text">
+          <string>Define New Endonuclease</string>
+         </property>
+        </widget>
+       </item>
+       <item row="0" column="0">
+        <widget class="QPushButton" name="pbtnNewGenome">
+         <property name="text">
+          <string>Analyze New Genome</string>
+         </property>
+        </widget>
+       </item>
+       <item row="1" column="0">
+        <widget class="QPushButton" name="pbtnMultitargetingAnalysis">
+         <property name="text">
+          <string>Multitargeting Analysis</string>
+         </property>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+    </item>
+    <item row="3" column="0" rowspan="2" colspan="2">
      <layout class="QGridLayout" name="gridStep1Step2Step3">
       <property name="sizeConstraint">
        <enum>QLayout::SetDefaultConstraint</enum>
       </item>
      </layout>
     </item>
    </layout>
   </widget>
   <action name="actionNew">

src/ui/main_window.ui CHANGED Viewed

@@ -71,7 +71,7 @@
      <x>0</x>
      <y>0</y>
      <width>901</width>
-     <height>37</height>
     </rect>
    </property>
    <property name="font">
@@ -83,28 +83,6 @@
      <bold>false</bold>
     </font>
    </property>
-   <widget class="QMenu" name="menuFile">
-    <property name="title">
-     <string>File</string>
-    </property>
-    <addaction name="actionExit"/>
-    <addaction name="actChangeDatabaseDirectory"/>
-   </widget>
-   <widget class="QMenu" name="menuTools">
-    <property name="title">
-     <string>Tools</string>
-    </property>
-    <addaction name="actOpenGenomeBrowser"/>
-   </widget>
-   <widget class="QMenu" name="menuLinks">
-    <property name="title">
-     <string>Links</string>
-    </property>
-    <addaction name="actGoToNCBI"/>
-    <addaction name="actionGoToNCBIBLAST"/>
-    <addaction name="separator"/>
-    <addaction name="actionGoToCASPERRepository"/>
-   </widget>
    <widget class="QMenu" name="menuCASPER">
     <property name="title">
      <string>CASPER</string>
@@ -112,9 +90,6 @@
     <addaction name="actionAbout_CASPER"/>
    </widget>
    <addaction name="menuCASPER"/>
-   <addaction name="menuFile"/>
-   <addaction name="menuTools"/>
-   <addaction name="menuLinks"/>
   </widget>
   <widget class="QToolBar" name="toolBar">
    <property name="windowTitle">

      <x>0</x>
      <y>0</y>
      <width>901</width>
+     <height>24</height>
     </rect>
    </property>
    <property name="font">
      <bold>false</bold>
     </font>
    </property>
    <widget class="QMenu" name="menuCASPER">
     <property name="title">
      <string>CASPER</string>
     <addaction name="actionAbout_CASPER"/>
    </widget>
    <addaction name="menuCASPER"/>
   </widget>
   <widget class="QToolBar" name="toolBar">
    <property name="windowTitle">

src/ui/new_genome_window.ui CHANGED Viewed

@@ -502,40 +502,6 @@ search parameters</string>
       </item>
      </layout>
     </item>
-    <item row="0" column="1">
-     <widget class="QLabel" name="lblWindowHeading">
-      <property name="minimumSize">
-       <size>
-        <width>0</width>
-        <height>0</height>
-       </size>
-      </property>
-      <property name="maximumSize">
-       <size>
-        <width>16777215</width>
-        <height>50</height>
-       </size>
-      </property>
-      <property name="font">
-       <font>
-        <family>Arial</family>
-        <pointsize>12</pointsize>
-        <weight>75</weight>
-        <italic>false</italic>
-        <bold>true</bold>
-       </font>
-      </property>
-      <property name="styleSheet">
-       <string notr="true"/>
-      </property>
-      <property name="text">
-       <string>Analyze New Genome</string>
-      </property>
-      <property name="scaledContents">
-       <bool>false</bool>
-      </property>
-     </widget>
-    </item>
     <item row="3" column="1" colspan="2">
      <widget class="QGroupBox" name="Step3">
       <property name="sizePolicy">

       </item>
      </layout>
     </item>
     <item row="3" column="1" colspan="2">
      <widget class="QGroupBox" name="Step3">
       <property name="sizePolicy">

src/ui/view_targets.ui CHANGED Viewed

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>1920</width>
-    <height>1147</height>
    </rect>
   </property>
   <property name="font">
@@ -22,68 +22,6 @@
    <layout class="QGridLayout" name="gridLayout_2">
     <item row="0" column="0">
      <layout class="QGridLayout" name="gridLayout">
-      <item row="0" column="1" rowspan="2">
-       <widget class="QGroupBox" name="grpGeneViewer">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
-        <property name="title">
-         <string>Gene Viewer</string>
-        </property>
-        <layout class="QGridLayout" name="gridLayout_6">
-         <item row="2" column="1">
-          <widget class="QLineEdit" name="ledStartLocation"/>
-         </item>
-         <item row="3" column="2">
-          <widget class="QPushButton" name="pbtnResetLocation">
-           <property name="text">
-            <string>Reset Location</string>
-           </property>
-          </widget>
-         </item>
-         <item row="2" column="0">
-          <widget class="QLabel" name="lblStartLocation">
-           <property name="text">
-            <string>Start:</string>
-           </property>
-          </widget>
-         </item>
-         <item row="3" column="1">
-          <widget class="QLineEdit" name="ledStopLocation"/>
-         </item>
-         <item row="3" column="0">
-          <widget class="QLabel" name="lblStopLocation">
-           <property name="text">
-            <string>Stop:</string>
-           </property>
-          </widget>
-         </item>
-         <item row="2" column="2">
-          <widget class="QPushButton" name="pbtnChangeLocation">
-           <property name="toolTip">
-            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;This button changes the start and end location of the Gene Viewer sequence, based on what is entered in the Start and Stop boxes.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-           </property>
-           <property name="text">
-            <string>Change Location</string>
-           </property>
-          </widget>
-         </item>
-         <item row="5" column="0" colspan="5">
-          <widget class="QTextEdit" name="txtedGeneViewer"/>
-         </item>
-         <item row="4" column="2">
-          <widget class="QCheckBox" name="chkViewExonsOnly">
-           <property name="text">
-            <string>View Exons Only</string>
-           </property>
-          </widget>
-         </item>
-        </layout>
-       </widget>
-      </item>
       <item row="0" column="0">
        <widget class="QGroupBox" name="grpGuideViewer">
         <property name="sizePolicy">
@@ -217,6 +155,93 @@
         </layout>
        </widget>
       </item>
      </layout>
     </item>
    </layout>

    <rect>
     <x>0</x>
     <y>0</y>
+    <width>1512</width>
+    <height>916</height>
    </rect>
   </property>
   <property name="font">
    <layout class="QGridLayout" name="gridLayout_2">
     <item row="0" column="0">
      <layout class="QGridLayout" name="gridLayout">
       <item row="0" column="0">
        <widget class="QGroupBox" name="grpGuideViewer">
         <property name="sizePolicy">
         </layout>
        </widget>
       </item>
+      <item row="0" column="1">
+       <widget class="QGroupBox" name="grpGeneViewer">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="title">
+         <string>Gene Viewer</string>
+        </property>
+        <layout class="QGridLayout" name="gridLayout_6">
+         <item row="3" column="1">
+          <widget class="QLineEdit" name="ledStopLocation"/>
+         </item>
+         <item row="4" column="0" colspan="2">
+          <widget class="QLabel" name="lblSequenceLegend">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+           <property name="layoutDirection">
+            <enum>Qt::LeftToRight</enum>
+           </property>
+           <property name="text">
+            <string>ACTG - Gene Sequence&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&lt;span style=&quot;color: rgb(100, 100, 100);&quot;&gt;actg&lt;/span&gt; - Padding Sequence</string>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="1">
+          <widget class="QLineEdit" name="ledStartLocation"/>
+         </item>
+         <item row="3" column="2">
+          <widget class="QPushButton" name="pbtnResetLocation">
+           <property name="text">
+            <string>Reset Location</string>
+           </property>
+          </widget>
+         </item>
+         <item row="3" column="0">
+          <widget class="QLabel" name="lblStopLocation">
+           <property name="text">
+            <string>Stop:</string>
+           </property>
+          </widget>
+         </item>
+         <item row="4" column="2">
+          <widget class="QCheckBox" name="chkViewExonsOnly">
+           <property name="autoFillBackground">
+            <bool>false</bool>
+           </property>
+           <property name="text">
+            <string>View Exons Only</string>
+           </property>
+          </widget>
+         </item>
+         <item row="5" column="0" colspan="5">
+          <widget class="QTextEdit" name="txtedGeneViewer"/>
+         </item>
+         <item row="2" column="0">
+          <widget class="QLabel" name="lblStartLocation">
+           <property name="text">
+            <string>Start:</string>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="2">
+          <widget class="QPushButton" name="pbtnChangeLocation">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+           <property name="toolTip">
+            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;This button changes the start and end location of the Gene Viewer sequence, based on what is entered in the Start and Stop boxes.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+           </property>
+           <property name="text">
+            <string>Change Location</string>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </widget>
+      </item>
      </layout>
     </item>
    </layout>

src/views/CloseableTabWidget.py CHANGED Viewed

@@ -6,6 +6,7 @@ import logging
 class CloseableTabWidget(QTabWidget):
     tab_closed = pyqtSignal(QWidget)
     def __init__(self, parent=None):
         super().__init__(parent)
@@ -19,27 +20,32 @@ class CloseableTabWidget(QTabWidget):
         """Close a tab at the given index"""
         self.logger.debug(f"Attempting to close tab at index {index}")
-        if not (self.count() > 1 and index != 0):
-            self.logger.debug("Tab closure conditions not met")
-            return
         widget = self.widget(index)
         if not widget:
             self.logger.warning(f"No widget found at index {index}")
             return
-        # Critical operations need try-catch
         try:
             tab_text = self.tabText(index)
             # Cleanup controller if exists
             controller = getattr(widget, 'controller', None)
-            if controller and hasattr(controller, 'model') and hasattr(controller.model, 'cleanup'):
-                controller.model.cleanup()
             # Remove from tracking and emit signal
-            if tab_text in self._tabs:
-                del self._tabs[tab_text]
             self.removeTab(index)
             self.tab_closed.emit(widget)
@@ -116,6 +122,8 @@ class CloseableTabWidget(QTabWidget):
             if 0 <= index < self.count():
                 current_widget = self.widget(index)
                 if current_widget and index != 0:
                     self.closeTab(index)
         except Exception as e:
             self.logger.error(f"Error in safely_close_tab: {e}")
@@ -166,4 +174,28 @@ class CloseableTabWidget(QTabWidget):
                 self._update_all_tabs()
         except Exception as e:
-            self.logger.error(f"Error moving tab: {e}")

 class CloseableTabWidget(QTabWidget):
     tab_closed = pyqtSignal(QWidget)
+    tab_closing = pyqtSignal(int)
     def __init__(self, parent=None):
         super().__init__(parent)
         """Close a tab at the given index"""
         self.logger.debug(f"Attempting to close tab at index {index}")
+        # Skip normal closure conditions for forced closure
+        if not hasattr(self, '_force_close'):
+            if not (self.count() > 1 and index != 0):
+                self.logger.debug("Tab closure conditions not met")
+                return
         widget = self.widget(index)
         if not widget:
             self.logger.warning(f"No widget found at index {index}")
             return
         try:
+            # Emit signal before closing the tab
+            self.tab_closing.emit(index)
             tab_text = self.tabText(index)
             # Cleanup controller if exists
             controller = getattr(widget, 'controller', None)
+            # if controller and hasattr(controller, 'model') and hasattr(controller.model, 'cleanup'):
+                # controller.model.cleanup()
             # Remove from tracking and emit signal
+            tab_id = f"{tab_text}_{id(widget)}"
+            if tab_id in self._tabs:
+                del self._tabs[tab_id]
             self.removeTab(index)
             self.tab_closed.emit(widget)
             if 0 <= index < self.count():
                 current_widget = self.widget(index)
                 if current_widget and index != 0:
+                    # Emit signal before closing
+                    self.tab_closing.emit(index)
                     self.closeTab(index)
         except Exception as e:
             self.logger.error(f"Error in safely_close_tab: {e}")
                 self._update_all_tabs()
         except Exception as e:
+            self.logger.error(f"Error moving tab: {e}")
+    def removeTab(self, index):
+        """Override removeTab to handle cleanup"""
+        try:
+            widget = self.widget(index)
+            if widget:
+                # Get tab text before removal
+                tab_text = self.tabText(index)
+                # Remove from tracking dictionary
+                tab_id = f"{tab_text}_{id(widget)}"
+                if tab_id in self._tabs:
+                    del self._tabs[tab_id]
+                # Remove the tab
+                super().removeTab(index)
+                # Cleanup the widget
+                widget.deleteLater()
+                self._update_all_tabs()
+        except Exception as e:
+            self.logger.error(f"Error removing tab: {e}")

src/views/FindTargetsView.py CHANGED Viewed

@@ -1,6 +1,6 @@
 from PyQt6 import QtWidgets
 from PyQt6.QtWidgets import (QWidget, QVBoxLayout, QTableWidget, QTableWidgetItem,
-                            QPushButton, QHBoxLayout, QLabel, QAbstractItemView)
 from PyQt6 import uic
 from PyQt6.QtCore import Qt, QTimer
 import time
@@ -17,10 +17,15 @@ class FindTargetsView(QtWidgets.QMainWindow):
     def _init_ui(self):
         uic.loadUi(self.global_settings.get_ui_dir_path() + '/find_targets.ui', self)
         self.results_table = self.findChild(QTableWidget, 'tblTargets')
         # Optimize table settings for large datasets
         self.results_table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
         self.results_table.setShowGrid(False)
         self.results_table.setAlternatingRowColors(True)
@@ -134,23 +139,28 @@ class FindTargetsView(QtWidgets.QMainWindow):
             selected_rows = set(index.row() for index in self.results_table.selectedIndexes())
             selected_targets = []
             # Get the currently visible rows from the table
-            visible_targets = []
-            for row in range(self.results_table.rowCount()):
-                if not self.results_table.isRowHidden(row):
                     # Get data from visible row
                     target_data = {
-                        'feature_type': self.results_table.item(row, 0).text(),
-                        'chromosome': self.results_table.item(row, 1).text(),
-                        'feature_id': self.results_table.item(row, 2).text(),
-                        'feature_name': self.results_table.item(row, 3).text(),
-                        'feature_description': self.results_table.item(row, 4).text()
                     }
-                    visible_targets.append((row, target_data))
-            # Match selected rows with visible targets
-            for row, target_data in visible_targets:
-                if row in selected_rows:
                     # Find corresponding full target data from _all_results
                     for full_target in self._all_results:
                         if (full_target['feature_id'] == target_data['feature_id'] and
@@ -158,6 +168,10 @@ class FindTargetsView(QtWidgets.QMainWindow):
                             selected_targets.append(full_target)
                             break
             self.logger.debug(f"Selected {len(selected_targets)} targets from filtered view")
             return selected_targets
@@ -173,8 +187,7 @@ class FindTargetsView(QtWidgets.QMainWindow):
         """Handle generate library button click"""
         try:
             selected_targets = self.get_selected_targets()
-            self.global_settings.logger.debug(f"Selected {len(selected_targets)} targets for library generation")
             if not selected_targets:
                 QtWidgets.QMessageBox.warning(
                     self,
@@ -183,14 +196,15 @@ class FindTargetsView(QtWidgets.QMainWindow):
                 )
                 return
             # Create and show generate library window
-            self.global_settings.logger.debug("Creating GenerateLibraryController")
             from controllers.GenerateLibraryController import GenerateLibraryController
             generate_library_controller = GenerateLibraryController(
                 self.global_settings,
                 selected_targets
             )
-            self.global_settings.logger.debug("Showing generate library window")
             generate_library_controller.show()
         except Exception as e:
@@ -200,3 +214,15 @@ class FindTargetsView(QtWidgets.QMainWindow):
                 "Error",
                 f"An error occurred while opening the generate library window: {str(e)}"
             )

 from PyQt6 import QtWidgets
 from PyQt6.QtWidgets import (QWidget, QVBoxLayout, QTableWidget, QTableWidgetItem,
+                            QPushButton, QHBoxLayout, QLabel, QAbstractItemView, QCheckBox)
 from PyQt6 import uic
 from PyQt6.QtCore import Qt, QTimer
 import time
     def _init_ui(self):
         uic.loadUi(self.global_settings.get_ui_dir_path() + '/find_targets.ui', self)
+        self.checkbox_select_all = self.findChild(QCheckBox, 'chkSelectAll')
         self.results_table = self.findChild(QTableWidget, 'tblTargets')
+        # Connect select all checkbox signal
+        self.checkbox_select_all.stateChanged.connect(self._on_select_all_changed)
         # Optimize table settings for large datasets
         self.results_table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
+        self.results_table.setSelectionMode(QTableWidget.SelectionMode.MultiSelection)
         self.results_table.setShowGrid(False)
         self.results_table.setAlternatingRowColors(True)
             selected_rows = set(index.row() for index in self.results_table.selectedIndexes())
             selected_targets = []
+            if not selected_rows:
+                self.logger.debug("No rows selected")
+                return []
             # Get the currently visible rows from the table
+            for row in selected_rows:
+                try:
+                    # Check if all required cells have valid data
+                    cells = [self.results_table.item(row, col) for col in range(5)]
+                    if any(cell is None for cell in cells):
+                        self.logger.warning(f"Row {row} has missing data, skipping")
+                        continue
                     # Get data from visible row
                     target_data = {
+                        'feature_type': cells[0].text(),
+                        'chromosome': cells[1].text(),
+                        'feature_id': cells[2].text(),
+                        'feature_name': cells[3].text(),
+                        'feature_description': cells[4].text()
                     }
                     # Find corresponding full target data from _all_results
                     for full_target in self._all_results:
                         if (full_target['feature_id'] == target_data['feature_id'] and
                             selected_targets.append(full_target)
                             break
+                except Exception as row_error:
+                    self.logger.warning(f"Error processing row {row}: {str(row_error)}")
+                    continue
             self.logger.debug(f"Selected {len(selected_targets)} targets from filtered view")
             return selected_targets
         """Handle generate library button click"""
         try:
             selected_targets = self.get_selected_targets()
             if not selected_targets:
                 QtWidgets.QMessageBox.warning(
                     self,
                 )
                 return
+            # Store selected targets in global settings for persistence
+            self.global_settings._current_selected_targets = selected_targets
             # Create and show generate library window
             from controllers.GenerateLibraryController import GenerateLibraryController
             generate_library_controller = GenerateLibraryController(
                 self.global_settings,
                 selected_targets
             )
             generate_library_controller.show()
         except Exception as e:
                 "Error",
                 f"An error occurred while opening the generate library window: {str(e)}"
             )
+    def _on_select_all_changed(self, state):
+        """Handle select all checkbox state changes"""
+        try:
+            self.results_table.setUpdatesEnabled(False)  # Disable updates for performance
+            if state == Qt.CheckState.Checked.value:
+                self.results_table.selectAll()
+            else:
+                self.results_table.clearSelection()
+            self.results_table.setUpdatesEnabled(True)  # Re-enable updates
+        except Exception as e:
+            self.logger.error(f"Error in select all handler: {str(e)}")

src/views/GenerateLibraryView.py CHANGED Viewed

@@ -24,7 +24,6 @@ class GenerateLibraryView(QMainWindow):
         try:
             # Load UI file
             ui_file = os.path.join(self.global_settings.get_ui_dir_path(), 'generate_library.ui')
-            self.logger.debug(f"Loading UI file from: {ui_file}")
             uic.loadUi(ui_file, self)
             # Set window properties
@@ -47,6 +46,9 @@ class GenerateLibraryView(QMainWindow):
             else:
                 self.ledFilePath.setText(default_path + "/")
             # Center the window
             self._center_window()
@@ -139,11 +141,19 @@ class GenerateLibraryView(QMainWindow):
                 )
             }
-            if self.chkFindOffTargets.isChecked():
                 try:
-                    settings['max_off_target_score'] = float(self.cmbMaximumOffTargetScore.text())
-                except ValueError:
-                    raise ValueError("Invalid maximum off-target score")
             return settings
@@ -180,3 +190,12 @@ class GenerateLibraryView(QMainWindow):
             "Success",
             message
         )

         try:
             # Load UI file
             ui_file = os.path.join(self.global_settings.get_ui_dir_path(), 'generate_library.ui')
             uic.loadUi(ui_file, self)
             # Set window properties
             else:
                 self.ledFilePath.setText(default_path + "/")
+            # Apply styles
+            self._set_styles()
             # Center the window
             self._center_window()
                 )
             }
+            if settings['find_off_targets']:
+                max_off_target_score = self.cmbMaximumOffTargetScore.text().strip()
+                if not max_off_target_score:
+                    raise ValueError("Please enter a maximum off-target score when Find Off Targets is enabled")
                 try:
+                    score = float(max_off_target_score)
+                    if not 0 <= score <= 0.5:
+                        raise ValueError("Maximum off-target score must be between 0 and 0.5 (inclusive)")
+                    settings['max_off_target_score'] = score
+                except ValueError as e:
+                    if str(e).startswith("Maximum"):
+                        raise
+                    raise ValueError("Invalid maximum off-target score - please enter a valid number")
             return settings
             "Success",
             message
         )
+    def _set_styles(self):
+        """Apply the global groupbox style"""
+        try:
+            style = self.global_settings.get_groupbox_style()
+            for groupbox in self.findChildren(QtWidgets.QGroupBox):
+                groupbox.setStyleSheet(style)
+        except Exception as e:
+            self.logger.error(f"Error setting styles: {str(e)}")

src/views/HomeWindowView.py CHANGED Viewed

@@ -14,9 +14,34 @@ class HomeWindowView(QWidget):
         try:
             uic.loadUi(os.path.join(self.global_settings.get_ui_dir_path(), "home_window.ui"), self)
             self._init_ui_elements()
         except Exception as e:
             self._handle_init_error(e)
     def _init_ui_elements(self) -> None:
         # Create a main layout to hold everything
         main_layout = QVBoxLayout(self)
@@ -39,15 +64,15 @@ class HomeWindowView(QWidget):
         self._init_grpStep3()
         # Connect to database manager signals
-        self.global_settings.db_manager.db_files_changed.connect(self._handle_db_files_changed)
-        self.global_settings.db_manager.db_state_changed.connect(self._handle_db_state_changed)
     def _init_grpNavigationMenu(self) -> None:
         self.push_button_new_genome = self._find_widget("pbtnNewGenome", QPushButton)
         self.push_button_new_endonuclease = self._find_widget("pbtnNewEndonuclease", QPushButton)
         self.push_button_multitargeting_analysis = self._find_widget("pbtnMultitargetingAnalysis", QPushButton)
         self.push_button_population_analysis = self._find_widget("pbtnPopulationAnalysis", QPushButton)
-        self.push_button_combine_files = self._find_widget("pbtnCombineFiles", QPushButton)
     def _init_grpStep1(self) -> None:
         self.combo_box_organism = self._find_widget("cmbOrganism", QComboBox)
@@ -90,17 +115,47 @@ class HomeWindowView(QWidget):
         show_error(self.global_settings, "Initialization Error", error_msg)
         raise
-    def update_combo_box_endonuclease(self, endonuclease: list) -> None:
-        self.combo_box_endonuclease.clear()
-        self.combo_box_endonuclease.addItems(endonuclease)
-    def update_combo_box_organism(self, organisms: list) -> None:
-        self.combo_box_organism.clear()
-        self.combo_box_organism.addItems(organisms)
-    # def update_combo_box_annotation_files(self, annotation_files: list) -> None:
-    #     self.combo_box_local_annotation_files.clear()
-    #     self.combo_box_local_annotation_files.addItems(annotation_files)
     def get_find_targets_input(self) -> dict:
         current_annotation = self.combo_box_local_annotation_files.currentText()
@@ -125,32 +180,6 @@ class HomeWindowView(QWidget):
     def get_annotation_file(self) -> str:
         return self.combo_box_local_annotation_files.currentText()
-    def update_combo_box_annotation_files(self, files):
-        """Update local annotation files combo box, excluding .index files"""
-        try:
-            # Clear existing items
-            self.combo_box_local_annotation_files.clear()
-            # Filter out .index files and ensure files are valid
-            filtered_files = [
-                f for f in files
-                if not f.endswith('.index') and f.strip()
-            ]
-            # Add filtered files to combo box
-            if filtered_files:
-                self.combo_box_local_annotation_files.addItems(filtered_files)
-                # Set the first item as current
-                self.combo_box_local_annotation_files.setCurrentIndex(0)
-                # Emit the change signal to update the current annotation file
-                self._on_annotation_file_changed(self.combo_box_local_annotation_files.currentText())
-                self.logger.debug(f"Added {len(filtered_files)} local annotation files to combo box")
-            else:
-                self.logger.debug("No local annotation files found")
-        except Exception as e:
-            self.logger.error(f"Error updating local annotation files: {str(e)}")
     def _on_annotation_file_changed(self, new_file):
         """Handle annotation file changes"""
         try:

         try:
             uic.loadUi(os.path.join(self.global_settings.get_ui_dir_path(), "home_window.ui"), self)
             self._init_ui_elements()
+            self._set_styles()
         except Exception as e:
             self._handle_init_error(e)
+    def _set_styles(self) -> None:
+        """Set the styles for the groupboxes"""
+        groupbox_style = """
+        QGroupBox:title {
+            subcontrol-origin: margin;
+            left: 10px;
+            padding: 0 5px 0 5px;
+        }
+        QGroupBox#grpStep1, QGroupBox#grpStep2, QGroupBox#grpStep3 {
+            border: 2px solid rgb(111,181,110);
+            border-radius: 9px;
+            margin-top: 10px;
+        }
+        QGroupBox#grpNavigationMenu {
+            border: 2px dashed rgb(88,89,91);
+            border-radius: 9px;
+            margin-top: 10px;
+        }
+        """
+        # Find and style all groupboxes
+        for child in self.findChildren(QtWidgets.QGroupBox):
+            child.setStyleSheet(groupbox_style)
     def _init_ui_elements(self) -> None:
         # Create a main layout to hold everything
         main_layout = QVBoxLayout(self)
         self._init_grpStep3()
         # Connect to database manager signals
+        # self.global_settings.db_manager.db_files_changed.connect(self._handle_db_files_changed)
+        # self.global_settings.db_manager.db_state_changed.connect(self._handle_db_state_changed)
     def _init_grpNavigationMenu(self) -> None:
         self.push_button_new_genome = self._find_widget("pbtnNewGenome", QPushButton)
         self.push_button_new_endonuclease = self._find_widget("pbtnNewEndonuclease", QPushButton)
         self.push_button_multitargeting_analysis = self._find_widget("pbtnMultitargetingAnalysis", QPushButton)
         self.push_button_population_analysis = self._find_widget("pbtnPopulationAnalysis", QPushButton)
+        # self.push_button_combine_files = self._find_widget("pbtnCombineFiles", QPushButton)
     def _init_grpStep1(self) -> None:
         self.combo_box_organism = self._find_widget("cmbOrganism", QComboBox)
         show_error(self.global_settings, "Initialization Error", error_msg)
         raise
+    def update_combo_box_endonuclease(self, endonucleases):
+        """Update the endonuclease combo box"""
+        try:
+            current_text = self.combo_box_endonuclease.currentText()
+            self.combo_box_endonuclease.clear()
+            self.combo_box_endonuclease.addItems(endonucleases)
+            # Try to restore previous selection if it still exists
+            index = self.combo_box_endonuclease.findText(current_text)
+            if index >= 0:
+                self.combo_box_endonuclease.setCurrentIndex(index)
+        except Exception as e:
+            self.logger.error(f"Error updating endonuclease combo box: {str(e)}")
+    def update_combo_box_organism(self, organisms):
+        """Update the organism combo box"""
+        try:
+            current_text = self.combo_box_organism.currentText()
+            self.combo_box_organism.clear()
+            self.combo_box_organism.addItems(organisms)
+            # Try to restore previous selection if it still exists
+            index = self.combo_box_organism.findText(current_text)
+            if index >= 0:
+                self.combo_box_organism.setCurrentIndex(index)
+        except Exception as e:
+            self.logger.error(f"Error updating organism combo box: {str(e)}")
+    def update_combo_box_annotation_files(self, files):
+        """Update the annotation files combo box"""
+        try:
+            current_text = self.combo_box_local_annotation_files.currentText()
+            self.combo_box_local_annotation_files.clear()
+            self.combo_box_local_annotation_files.addItems(files)
+            # Try to restore previous selection if it still exists
+            index = self.combo_box_local_annotation_files.findText(current_text)
+            if index >= 0:
+                self.combo_box_local_annotation_files.setCurrentIndex(index)
+        except Exception as e:
+            self.logger.error(f"Error updating annotation files combo box: {str(e)}")
     def get_find_targets_input(self) -> dict:
         current_annotation = self.combo_box_local_annotation_files.currentText()
     def get_annotation_file(self) -> str:
         return self.combo_box_local_annotation_files.currentText()
     def _on_annotation_file_changed(self, new_file):
         """Handle annotation file changes"""
         try:

src/views/LoadingDialog.py CHANGED Viewed

@@ -25,36 +25,18 @@ class LoadingDialog(QDialog):
         layout.addWidget(self.progress_bar)
         self.setLayout(layout)
-        # Center on main window
         self.center_on_parent()
     def center_on_parent(self):
-        """Center the dialog on the main window or parent"""
-        parent = self.parent()
-        if parent:
-            # Get the main window from global settings if available
-            main_window = None
-            if hasattr(parent, 'global_settings'):
-                main_window = parent.global_settings.main_window
-            elif hasattr(parent, 'settings'):
-                main_window = parent.settings.main_window
-            # Get geometry of the window to center on
-            if main_window and main_window.view:
-                geometry = main_window.view.geometry()
-            else:
-                geometry = parent.geometry()
-            # Calculate center position
-            x = geometry.x() + (geometry.width() - self.width()) // 2
-            y = geometry.y() + (geometry.height() - self.height()) // 2
-            # Ensure dialog stays within screen bounds
-            screen = QApplication.primaryScreen().geometry()
-            x = max(screen.left(), min(x, screen.right() - self.width()))
-            y = max(screen.top(), min(y, screen.bottom() - self.height()))
             self.move(x, y)
     def set_message(self, message, progress=None):
@@ -62,8 +44,6 @@ class LoadingDialog(QDialog):
         if progress is not None:
             self.progress_bar.setValue(progress)
         self.label.setText(message)
-        # Recenter after updating message
         self.center_on_parent()
     def set_progress(self, value):
@@ -75,9 +55,4 @@ class LoadingDialog(QDialog):
         """Set indeterminate progress"""
         self.progress_bar.setRange(0, 0)
         self.label.setText("Loading...")
-    def showEvent(self, event):
-        """Override show event to ensure dialog is centered when shown"""
-        super().showEvent(event)
-        self.center_on_parent()

         layout.addWidget(self.progress_bar)
         self.setLayout(layout)
+    def showEvent(self, event):
+        """Override show event to ensure dialog is centered when shown"""
+        super().showEvent(event)
         self.center_on_parent()
     def center_on_parent(self):
+        """Center the dialog on the parent window"""
+        if self.parent():
+            parent_geometry = self.parent().geometry()
+            x = parent_geometry.x() + (parent_geometry.width() - self.width()) // 2
+            y = parent_geometry.y() + (parent_geometry.height() - self.height()) // 2
             self.move(x, y)
     def set_message(self, message, progress=None):
         if progress is not None:
             self.progress_bar.setValue(progress)
         self.label.setText(message)
         self.center_on_parent()
     def set_progress(self, value):
         """Set indeterminate progress"""
         self.progress_bar.setRange(0, 0)
         self.label.setText("Loading...")

src/views/MultitargetingWindowView.py CHANGED Viewed

@@ -25,9 +25,19 @@ class MultitargetingWindowView(QtWidgets.QMainWindow):
         try:
             uic.loadUi(self.settings.get_ui_dir_path() + '/multitargeting_window.ui', self)
             self._init_ui_components()
         except Exception as e:
             show_error(self.settings, "Error initializing MultitargetingWindowView", str(e))
     def _init_ui_components(self):
         self._init_grpSelectOrganism()
         self._init_grpSeedAnalysis()

         try:
             uic.loadUi(self.settings.get_ui_dir_path() + '/multitargeting_window.ui', self)
             self._init_ui_components()
+            self._set_styles()
         except Exception as e:
             show_error(self.settings, "Error initializing MultitargetingWindowView", str(e))
+    def _set_styles(self):
+        """Apply the global groupbox style"""
+        try:
+            style = self.settings.get_groupbox_style()
+            for groupbox in self.findChildren(QtWidgets.QGroupBox):
+                groupbox.setStyleSheet(style)
+        except Exception as e:
+            self.logger.error(f"Error setting styles: {str(e)}")
     def _init_ui_components(self):
         self._init_grpSelectOrganism()
         self._init_grpSeedAnalysis()

src/views/NCBIWindowView.py CHANGED Viewed

@@ -2,6 +2,7 @@ from PyQt6 import QtWidgets, QtGui, QtCore, uic
 from PyQt6.QtWidgets import QWidget, QVBoxLayout
 import os
 from typing import Optional
 class NCBIWindowView(QtWidgets.QMainWindow):
     initialization_complete = QtCore.pyqtSignal()  # New signal
@@ -18,27 +19,53 @@ class NCBIWindowView(QtWidgets.QMainWindow):
     def _setup_basic_ui(self):
         """Initial minimal setup to show the window quickly"""
         try:
             uic.loadUi(os.path.join(self.settings.get_ui_dir_path(), "ncbi.ui"), self)
             QtCore.QTimer.singleShot(100, self._complete_initialization)
         except Exception as e:
             self.logger.error(f"Error in basic UI setup: {str(e)}")
             raise
     def _complete_initialization(self):
         """Complete the full initialization of UI components"""
         try:
             if self._is_initialized:
                 return
             # Initialize all UI components
             self._init_ui_components()
             self._is_initialized = True
             # Emit signal after everything is initialized
             self.initialization_complete.emit()
         except Exception as e:
             self.logger.error(f"Error in complete initialization: {str(e)}")
@@ -47,9 +74,20 @@ class NCBIWindowView(QtWidgets.QMainWindow):
     def _init_ui_components(self) -> None:
         """Initialize all UI components at once instead of using timers"""
         try:
             self._init_grpStep1()
             self._init_grpStep2()
             self._init_grpStep3()
         except Exception as e:
             self.logger.error(f"Error in _init_ui_components: {str(e)}")
             raise

 from PyQt6.QtWidgets import QWidget, QVBoxLayout
 import os
 from typing import Optional
+import time
 class NCBIWindowView(QtWidgets.QMainWindow):
     initialization_complete = QtCore.pyqtSignal()  # New signal
     def _setup_basic_ui(self):
         """Initial minimal setup to show the window quickly"""
         try:
+            start_time = time.time()
+            self.logger.debug("Starting basic UI setup")
+            ui_load_start = time.time()
             uic.loadUi(os.path.join(self.settings.get_ui_dir_path(), "ncbi.ui"), self)
+            self.logger.debug(f"Loading UI file took: {time.time() - ui_load_start:.2f} seconds")
+            # Apply styles immediately for better visual experience
+            self._set_styles()
             QtCore.QTimer.singleShot(100, self._complete_initialization)
+            self.logger.debug(f"Basic UI setup completed in: {time.time() - start_time:.2f} seconds")
         except Exception as e:
             self.logger.error(f"Error in basic UI setup: {str(e)}")
             raise
+    def _set_styles(self):
+        """Apply the global groupbox style"""
+        try:
+            style = self.settings.get_groupbox_style()
+            for groupbox in self.findChildren(QtWidgets.QGroupBox):
+                groupbox.setStyleSheet(style)
+        except Exception as e:
+            self.logger.error(f"Error setting styles: {str(e)}")
     def _complete_initialization(self):
         """Complete the full initialization of UI components"""
         try:
             if self._is_initialized:
                 return
+            start_time = time.time()
+            self.logger.debug("Starting complete initialization")
             # Initialize all UI components
+            components_start = time.time()
             self._init_ui_components()
+            self.logger.debug(f"UI components initialization took: {time.time() - components_start:.2f} seconds")
             self._is_initialized = True
             # Emit signal after everything is initialized
             self.initialization_complete.emit()
+            self.logger.debug("Emitted initialization complete signal")
+            self.logger.debug(f"Complete initialization finished in: {time.time() - start_time:.2f} seconds")
         except Exception as e:
             self.logger.error(f"Error in complete initialization: {str(e)}")
     def _init_ui_components(self) -> None:
         """Initialize all UI components at once instead of using timers"""
         try:
+            self.logger.debug("Starting UI components initialization")
+            step1_start = time.time()
             self._init_grpStep1()
+            self.logger.debug(f"Step 1 initialization took: {time.time() - step1_start:.2f} seconds")
+            step2_start = time.time()
             self._init_grpStep2()
+            self.logger.debug(f"Step 2 initialization took: {time.time() - step2_start:.2f} seconds")
+            step3_start = time.time()
             self._init_grpStep3()
+            self.logger.debug(f"Step 3 initialization took: {time.time() - step3_start:.2f} seconds")
         except Exception as e:
             self.logger.error(f"Error in _init_ui_components: {str(e)}")
             raise

src/views/NewEndonucleaseView.py CHANGED Viewed

@@ -99,16 +99,6 @@ class NewEndonucleaseView(QtWidgets.QMainWindow):
                 image: none;
                 border: none;
             }}
-            QGroupBox {{
-                border: 1px solid {theme['button_border_color']};
-                margin-top: 1em;
-                padding-top: 0.5em;
-            }}
-            QGroupBox::title {{
-                subcontrol-origin: margin;
-                left: 10px;
-                padding: 0 3px 0 3px;
-            }}
             QRadioButton {{
                 color: {theme['fg_color']};
             }}
@@ -132,19 +122,32 @@ class NewEndonucleaseView(QtWidgets.QMainWindow):
         """)
     def showEvent(self, event):
-        """Override showEvent to apply theme when window is shown"""
         super().showEvent(event)
-        self.apply_theme()
     def init_ui(self):
         try:
             uic.loadUi(os.path.join(self.settings.get_ui_dir_path(), 'new_endonuclease_window.ui'), self)
             self._init_ui_components()
             self.disable_form_elements()
         except Exception as e:
             show_error(self.settings, "Error initializing NewEndonucleaseView", str(e))
     def _init_ui_components(self):
         self.combo_box_select_endonuclease = self._find_widget('cmbSelectEndonuclease', QtWidgets.QComboBox)

                 image: none;
                 border: none;
             }}
             QRadioButton {{
                 color: {theme['fg_color']};
             }}
         """)
     def showEvent(self, event):
+        """Override showEvent to apply theme and styles when window is shown"""
         super().showEvent(event)
+        self._set_styles()
     def init_ui(self):
         try:
             uic.loadUi(os.path.join(self.settings.get_ui_dir_path(), 'new_endonuclease_window.ui'), self)
             self._init_ui_components()
+            self._set_styles()  # Add style initialization
             self.disable_form_elements()
         except Exception as e:
             show_error(self.settings, "Error initializing NewEndonucleaseView", str(e))
+    def _set_styles(self):
+        """Apply the global groupbox style and theme"""
+        try:
+            # Apply global groupbox style
+            style = self.settings.get_groupbox_style()
+            for groupbox in self.findChildren(QtWidgets.QGroupBox):
+                groupbox.setStyleSheet(style)
+            # Apply theme
+            self.apply_theme()
+        except Exception as e:
+            self.logger.error(f"Error setting styles: {str(e)}")
     def _init_ui_components(self):
         self.combo_box_select_endonuclease = self._find_widget('cmbSelectEndonuclease', QtWidgets.QComboBox)

src/views/NewGenomeWindowView.py CHANGED Viewed

@@ -18,23 +18,17 @@ class NewGenomeWindowView(QtWidgets.QMainWindow):
     def _init_ui(self):
         uic.loadUi(os.path.join(self.global_settings.get_ui_dir_path(), 'new_genome_window.ui'), self)
-        # self.set_styles()
         self._init_ui_components()
-    def set_styles(self):
-        groupbox_style = """
-        QGroupBox:title{subcontrol-origin: margin;
-                        left: 10px;
-                        padding: 0 5px 0 5px;}
-        QGroupBox#Step1{border: 2px solid rgb(111,181,110);
-                        border-radius: 9px;
-                        font: bold 14pt 'Arial';
-                        margin-top: 10px;}"""
-        self.Step1.setStyleSheet(groupbox_style)
-        self.Step2.setStyleSheet(groupbox_style.replace("Step1","Step2"))
-        self.Step3.setStyleSheet(groupbox_style.replace("Step1","Step3"))
     def _init_ui_components(self):
         self._init_grpStep1()

     def _init_ui(self):
         uic.loadUi(os.path.join(self.global_settings.get_ui_dir_path(), 'new_genome_window.ui'), self)
         self._init_ui_components()
+        self._set_styles()
+    def _set_styles(self):
+        """Apply the global groupbox style"""
+        try:
+            style = self.global_settings.get_groupbox_style()
+            for groupbox in self.findChildren(QtWidgets.QGroupBox):
+                groupbox.setStyleSheet(style)
+        except Exception as e:
+            self.logger.error(f"Error setting styles: {str(e)}")
     def _init_ui_components(self):
         self._init_grpStep1()

src/views/PopulationAnalysisWindowView.py CHANGED Viewed

@@ -24,6 +24,7 @@ class PopulationAnalysisWindowView(QtWidgets.QMainWindow):
         try:
             uic.loadUi(self.settings.get_ui_dir_path() + '/population_analysis.ui', self)
             self._init_ui_components()
         except Exception as e:
             show_error(self.settings, "Error initializing PopulationAnalysisWindowView", str(e))
@@ -35,8 +36,6 @@ class PopulationAnalysisWindowView(QtWidgets.QMainWindow):
     def _init_grpSelectOrganisms(self):
         try:
-            self.logger.debug("Starting _init_grpSelectOrganisms")
             self.combo_box_endonuclease = self._find_widget('cmbEndonuclease', QtWidgets.QComboBox)
             self.table_organism = self._find_widget('tblOrganism', QtWidgets.QTableWidget)
             self.push_button_analyze_organism = self._find_widget('pbtnAnalyzeOrganism', QtWidgets.QPushButton)
@@ -46,9 +45,6 @@ class PopulationAnalysisWindowView(QtWidgets.QMainWindow):
             self.tab_shared_seed_heatmap = self._find_widget('tabSharedSeedHeatmap', QtWidgets.QWidget)
             self.heatmap_seed = self._find_widget('heatmapSeed', QtWidgets.QWidget)
-            self.logger.debug(f"Tab widget found: {self.tab_widget_shared_seeds_heatmap is not None}")
-            self.logger.debug(f"Heatmap widget found: {self.heatmap_seed is not None}")
             # Create layout for heatmap
             self.colormap_layout = QtWidgets.QVBoxLayout(self.heatmap_seed)
             self.colormap_layout.setContentsMargins(0, 0, 0, 0)
@@ -58,7 +54,6 @@ class PopulationAnalysisWindowView(QtWidgets.QMainWindow):
             self.colormap_layout.addWidget(self.colormap_canvas)
             # Set up the organism table
-            self.logger.debug("Setting up organism table")
             self.table_organism.setColumnCount(1)
             self.table_organism.setShowGrid(False)
             self.table_organism.setHorizontalHeaderLabels(["Organism"])
@@ -68,8 +63,6 @@ class PopulationAnalysisWindowView(QtWidgets.QMainWindow):
             self.table_organism.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
             self.table_organism.setSelectionMode(QAbstractItemView.SelectionMode.MultiSelection)
-            self.logger.debug("Completed _init_grpSelectOrganisms")
         except Exception as e:
             self.logger.error(f"Error in _init_grpSelectOrganisms: {str(e)}")
             self.logger.exception("Full traceback:")
@@ -138,7 +131,6 @@ class PopulationAnalysisWindowView(QtWidgets.QMainWindow):
     def update_shared_seeds_table(self, seed_data):
         self.table_seed.setRowCount(len(seed_data))
         for row, data in enumerate(seed_data):
-            print(data)
             for col, value in enumerate(data):
                 item = QtWidgets.QTableWidgetItem(str(value))
                 item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
@@ -148,7 +140,6 @@ class PopulationAnalysisWindowView(QtWidgets.QMainWindow):
     def update_loc_finder_table(self, loc_data):
         self.table_locations.setRowCount(len(loc_data))
         for row, data in enumerate(loc_data):
-            print(data)
             for col, key in enumerate(['seed', 'sequence', 'organism', 'chromosome', 'location']):
                 item = QtWidgets.QTableWidgetItem(str(data[key]))
                 item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
@@ -253,35 +244,22 @@ class PopulationAnalysisWindowView(QtWidgets.QMainWindow):
         self.table_seed.setRowCount(0)
     def clear_loc_finder_table(self):
-        self.loc_finder_table.setRowCount(0)
     def update_endo_dropdown(self, endos):
         """Update the endonuclease dropdown with the provided options"""
         try:
-            self.logger.info("Starting update_endo_dropdown")
-            self.logger.debug(f"Received endos: {endos}")
-            print(self.combo_box_endonuclease)
-            # if not self.combo_box_endonuclease:
-                # self.logger.error("combo_box_endonuclease is None")
-                # return
             self.combo_box_endonuclease.clear()
             self.combo_box_endonuclease.addItems(endos)
-            self.logger.info(f"Updated endonuclease dropdown with {len(endos)} options")
-            self.logger.debug(f"Current items in dropdown: {[self.combo_box_endonuclease.itemText(i) for i in range(self.combo_box_endonuclease.count())]}")
         except Exception as e:
             self.logger.error(f"Error updating endonuclease dropdown: {str(e)}")
-            self.logger.exception("Full traceback:")
             show_error(self.settings, "Error updating endonuclease dropdown", str(e))
     def sort_table2(self, column):
         self.table_seed.sortItems(column)
     def sort_loc_finder_table(self, column):
-        self.loc_finder_table.sortItems(column)
     def _on_theme_changed(self, theme):
         """Handle theme changes by updating the plot"""
@@ -307,6 +285,15 @@ class PopulationAnalysisWindowView(QtWidgets.QMainWindow):
         except Exception as e:
             self.logger.error(f"Error updating plot theme: {str(e)}")
 class MplCanvas(FigureCanvasQTAgg):
     def __init__(self, parent=None, width=8, height=6, dpi=100):
         self.fig = Figure(figsize=(width, height), dpi=dpi)

         try:
             uic.loadUi(self.settings.get_ui_dir_path() + '/population_analysis.ui', self)
             self._init_ui_components()
+            self._set_styles()
         except Exception as e:
             show_error(self.settings, "Error initializing PopulationAnalysisWindowView", str(e))
     def _init_grpSelectOrganisms(self):
         try:
             self.combo_box_endonuclease = self._find_widget('cmbEndonuclease', QtWidgets.QComboBox)
             self.table_organism = self._find_widget('tblOrganism', QtWidgets.QTableWidget)
             self.push_button_analyze_organism = self._find_widget('pbtnAnalyzeOrganism', QtWidgets.QPushButton)
             self.tab_shared_seed_heatmap = self._find_widget('tabSharedSeedHeatmap', QtWidgets.QWidget)
             self.heatmap_seed = self._find_widget('heatmapSeed', QtWidgets.QWidget)
             # Create layout for heatmap
             self.colormap_layout = QtWidgets.QVBoxLayout(self.heatmap_seed)
             self.colormap_layout.setContentsMargins(0, 0, 0, 0)
             self.colormap_layout.addWidget(self.colormap_canvas)
             # Set up the organism table
             self.table_organism.setColumnCount(1)
             self.table_organism.setShowGrid(False)
             self.table_organism.setHorizontalHeaderLabels(["Organism"])
             self.table_organism.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
             self.table_organism.setSelectionMode(QAbstractItemView.SelectionMode.MultiSelection)
         except Exception as e:
             self.logger.error(f"Error in _init_grpSelectOrganisms: {str(e)}")
             self.logger.exception("Full traceback:")
     def update_shared_seeds_table(self, seed_data):
         self.table_seed.setRowCount(len(seed_data))
         for row, data in enumerate(seed_data):
             for col, value in enumerate(data):
                 item = QtWidgets.QTableWidgetItem(str(value))
                 item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
     def update_loc_finder_table(self, loc_data):
         self.table_locations.setRowCount(len(loc_data))
         for row, data in enumerate(loc_data):
             for col, key in enumerate(['seed', 'sequence', 'organism', 'chromosome', 'location']):
                 item = QtWidgets.QTableWidgetItem(str(data[key]))
                 item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
         self.table_seed.setRowCount(0)
     def clear_loc_finder_table(self):
+        self.table_locations.setRowCount(0)
     def update_endo_dropdown(self, endos):
         """Update the endonuclease dropdown with the provided options"""
         try:
             self.combo_box_endonuclease.clear()
             self.combo_box_endonuclease.addItems(endos)
         except Exception as e:
             self.logger.error(f"Error updating endonuclease dropdown: {str(e)}")
             show_error(self.settings, "Error updating endonuclease dropdown", str(e))
     def sort_table2(self, column):
         self.table_seed.sortItems(column)
     def sort_loc_finder_table(self, column):
+        self.table_locations.sortItems(column)
     def _on_theme_changed(self, theme):
         """Handle theme changes by updating the plot"""
         except Exception as e:
             self.logger.error(f"Error updating plot theme: {str(e)}")
+    def _set_styles(self):
+        """Apply the global groupbox style"""
+        try:
+            style = self.settings.get_groupbox_style()
+            for groupbox in self.findChildren(QtWidgets.QGroupBox):
+                groupbox.setStyleSheet(style)
+        except Exception as e:
+            self.logger.error(f"Error setting styles: {str(e)}")
 class MplCanvas(FigureCanvasQTAgg):
     def __init__(self, parent=None, width=8, height=6, dpi=100):
         self.fig = Figure(figsize=(width, height), dpi=dpi)

src/views/StartupWindowView.py CHANGED Viewed

@@ -75,9 +75,10 @@ class StartupWindowView(QtWidgets.QMainWindow):
         if is_valid:
             self.label_db_status.hide()
             self.push_button_go_to_home_or_new_genome.setText("Go to Home")
         else:
             self.label_db_status.setText(message)
             self.label_db_status.show()
             self.label_db_status.setStyleSheet("color: red;")
             self.push_button_go_to_home_or_new_genome.setText("Analyze a New Genome")
-        self.push_button_go_to_home_or_new_genome.setEnabled(True)

         if is_valid:
             self.label_db_status.hide()
             self.push_button_go_to_home_or_new_genome.setText("Go to Home")
+            self.push_button_go_to_home_or_new_genome.setEnabled(True)
         else:
             self.label_db_status.setText(message)
             self.label_db_status.show()
             self.label_db_status.setStyleSheet("color: red;")
             self.push_button_go_to_home_or_new_genome.setText("Analyze a New Genome")
+            self.push_button_go_to_home_or_new_genome.setEnabled(True)

src/views/ViewTargetsView.py CHANGED Viewed

@@ -1,11 +1,12 @@
 from typing import Optional
 from PyQt6 import QtWidgets, uic
-from PyQt6.QtWidgets import QTableWidgetItem, QAbstractItemView
-from PyQt6.QtGui import QTextDocument
-from PyQt6.QtCore import Qt, pyqtSignal
 from utils.ui import show_error
 import traceback
-from views.DNAFeatureViewer import DNAFeatureViewer
 class ViewTargetsView(QtWidgets.QMainWindow):
     # Define the signal
@@ -21,10 +22,21 @@ class ViewTargetsView(QtWidgets.QMainWindow):
     def init_ui(self):
         try:
             uic.loadUi(self.settings.get_ui_dir_path() + '/view_targets.ui', self)
             self._init_ui_components()
         except Exception as e:
             show_error(self.settings, "Error initializing ViewTargetsView", str(e))
     def _init_ui_components(self):
         self._init_grpGuideViewer()
         self._init_grpGuideAnalysis()
@@ -75,6 +87,7 @@ class ViewTargetsView(QtWidgets.QMainWindow):
         self.push_button_cotargeting = self._find_widget('pbtnCoTargeting', QtWidgets.QPushButton)
     def _init_grpGeneViewer(self):
         self.push_button_highlight_guides = self._find_widget('pbtnHighlightGuides', QtWidgets.QPushButton)
         self.push_button_clear_guides = self._find_widget('pbtnClearGuides', QtWidgets.QPushButton)
         self.line_edit_start_location = self._find_widget('ledStartLocation', QtWidgets.QLineEdit)
@@ -82,31 +95,47 @@ class ViewTargetsView(QtWidgets.QMainWindow):
         self.push_button_change_location = self._find_widget('pbtnChangeLocation', QtWidgets.QPushButton)
         self.text_edit_gene_viewer = self._find_widget('txtedGeneViewer', QtWidgets.QTextEdit)
         self.push_button_reset_location = self._find_widget('pbtnResetLocation', QtWidgets.QPushButton)
         self.check_box_view_exons_only = self._find_widget('chkViewExonsOnly', QtWidgets.QCheckBox)
-        self.text_edit_gene_viewer.setReadOnly(True)
-        # Create DNA feature viewer
-        self.dna_feature_viewer = DNAFeatureViewer()
-        # Get the layout of the gene viewer group
-        gene_viewer_group = self.findChild(QtWidgets.QGroupBox, 'grpGeneViewer')
-        gene_viewer_layout = gene_viewer_group.layout()
-        # Find the row index of the text editor
-        text_editor_row = -1
-        for i in range(gene_viewer_layout.rowCount()):
-            item = gene_viewer_layout.itemAtPosition(i, 0)
-            if item and item.widget() == self.text_edit_gene_viewer:
-                text_editor_row = i
-                break
-        if text_editor_row != -1:
-            # Insert DNA feature viewer above the text editor
-            gene_viewer_layout.addWidget(self.dna_feature_viewer, text_editor_row, 0, 1, -1)
-        # Connect signals
-        self.dna_feature_viewer.sequence_selected.connect(self._on_sequence_selected)
     def _find_widget(self, name: str, widget_type: type) -> Optional[QtWidgets.QWidget]:
         widget = self.findChild(widget_type, name)
@@ -114,10 +143,9 @@ class ViewTargetsView(QtWidgets.QMainWindow):
             self.logger.warning(f"Widget '{name}' not found in UI file.")
         return widget
-    def display_guides_in_table(self, guides):
         try:
             self._all_guides = guides
             selected_text = self.combo_box_gene.currentText()
             # First filter by position/feature
@@ -138,6 +166,7 @@ class ViewTargetsView(QtWidgets.QMainWindow):
                             filtered_guides.append(guide)
                 else:
                     filtered_guides = self._all_guides
             # Apply additional filters
             final_guides = []
@@ -157,13 +186,13 @@ class ViewTargetsView(QtWidgets.QMainWindow):
             # Update table with new guides
             total_rows = len(final_guides)
-            self.logger.debug(f"Processing {total_rows} rows for display after filtering")
-            # Completely freeze UI
-            self.setUpdatesEnabled(False)
-            self.table_guides.setUpdatesEnabled(False)
-            self.table_guides.setSortingEnabled(False)
-            self.table_guides.setVisible(False)
             try:
                 # Clear and resize table
@@ -237,11 +266,12 @@ class ViewTargetsView(QtWidgets.QMainWindow):
                 guide_viewer_group.setMinimumWidth(essential_columns_width + 50)  # Add some padding for scrollbar
             finally:
-                # Re-enable UI
-                self.table_guides.setVisible(True)
-                self.table_guides.setUpdatesEnabled(True)
-                self.setUpdatesEnabled(True)
-                self.table_guides.setSortingEnabled(True)
         except Exception as e:
             self.logger.error(f"Error in display_guides: {str(e)}")
@@ -390,9 +420,6 @@ class ViewTargetsView(QtWidgets.QMainWindow):
             # Clear existing items efficiently
             self.combo_box_gene.clear()
-            # Debug logging
-            self.logger.debug(f"Received {len(genes)} genes")
             # Use a set to ensure uniqueness
             unique_genes = list(set(genes))
@@ -404,8 +431,6 @@ class ViewTargetsView(QtWidgets.QMainWindow):
                 # Set first item without triggering updates
                 if self.combo_box_gene.count() > 0:
                     self.combo_box_gene.setCurrentIndex(0)
-                self.logger.debug(f"Added {len(unique_genes)} unique genes to combo box")
             # Re-enable UI updates
             self.combo_box_gene.setUpdatesEnabled(True)
@@ -429,22 +454,26 @@ class ViewTargetsView(QtWidgets.QMainWindow):
     def update_gene_viewer(self, sequence, features=None):
         """Update both text editor and DNA feature viewer"""
-        # Update text editor
-        self.text_edit_gene_viewer.clear()
-        doc = QTextDocument()
-        doc.setHtml(sequence)
-        self.text_edit_gene_viewer.setDocument(doc)
-        # Get start position from line edit
         try:
-            start_pos = int(self.line_edit_start_location.text())
-        except (ValueError, TypeError):
-            start_pos = 1
-        # Update DNA feature viewer
-        if features is None:
-            features = []
-        self.dna_feature_viewer.set_data(sequence, features, start_pos)
     def select_all_guides(self, select):
         for row in range(self.table_guides.rowCount()):
@@ -559,40 +588,256 @@ class ViewTargetsView(QtWidgets.QMainWindow):
             self.logger.error(f"Error showing details: {str(e)}")
             show_error(self.settings, "Error showing details", str(e))
-    def _on_sequence_selected(self, start, end):
-        """Handle sequence selection in DNA feature viewer"""
-        self.line_edit_start_location.setText(str(start))
-        self.line_edit_stop_location.setText(str(end))
-    def highlight_guides_in_viewer(self, guides_to_highlight, sequence):
-        """Highlight guides in viewer"""
         try:
-            for guide in guides_to_highlight:
-                sequence_to_find = guide['sequence']
-                strand = guide['strand']
-                if strand == '-':
-                    sequence_to_find = str(Seq(sequence_to_find).reverse_complement())
-                sequence_upper = sequence.upper()
-                target_upper = sequence_to_find.upper()
-                pos = sequence_upper.find(target_upper)
-                if pos != -1:
-                    # Set color based on strand
-                    color = QColor(255, 0, 0, 100) if strand == '-' else QColor(0, 255, 0, 100)
-                    # Highlight sequence in viewer
-                    self.dna_feature_viewer.sequence_viewer.highlight_sequence(
-                        pos,
-                        pos + len(sequence_to_find) - 1,
-                        color
-                    )
         except Exception as e:
-            self.logger.error(f"Error highlighting guides: {str(e)}")
-            show_error(self.settings, "Error highlighting guides", str(e))
-    def clear_highlights(self):
-        """Clear highlights in viewer"""
-        self.dna_feature_viewer.sequence_viewer.clear_highlights()

 from typing import Optional
 from PyQt6 import QtWidgets, uic
+from PyQt6.QtWidgets import QTableWidgetItem, QAbstractItemView, QMessageBox, QApplication, QDialog
+from PyQt6.QtGui import QTextDocument, QKeySequence, QColor
+from PyQt6.QtCore import Qt, pyqtSignal, QEvent
 from utils.ui import show_error
 import traceback
+from views.dna_viewer.dna_feature_viewer import DNAFeatureViewer
+from .dialogs.base_insertion_dialog import BaseInsertionDialog
 class ViewTargetsView(QtWidgets.QMainWindow):
     # Define the signal
     def init_ui(self):
         try:
             uic.loadUi(self.settings.get_ui_dir_path() + '/view_targets.ui', self)
+            self.dna_feature_viewer = DNAFeatureViewer(parent=self)
             self._init_ui_components()
+            self._set_styles()  # Add style initialization
         except Exception as e:
             show_error(self.settings, "Error initializing ViewTargetsView", str(e))
+    def _set_styles(self):
+        """Apply the global groupbox style"""
+        try:
+            style = self.settings.get_groupbox_style()
+            for groupbox in self.findChildren(QtWidgets.QGroupBox):
+                groupbox.setStyleSheet(style)
+        except Exception as e:
+            self.logger.error(f"Error setting styles: {str(e)}")
     def _init_ui_components(self):
         self._init_grpGuideViewer()
         self._init_grpGuideAnalysis()
         self.push_button_cotargeting = self._find_widget('pbtnCoTargeting', QtWidgets.QPushButton)
     def _init_grpGeneViewer(self):
+        """Initialize gene viewer group"""
         self.push_button_highlight_guides = self._find_widget('pbtnHighlightGuides', QtWidgets.QPushButton)
         self.push_button_clear_guides = self._find_widget('pbtnClearGuides', QtWidgets.QPushButton)
         self.line_edit_start_location = self._find_widget('ledStartLocation', QtWidgets.QLineEdit)
         self.push_button_change_location = self._find_widget('pbtnChangeLocation', QtWidgets.QPushButton)
         self.text_edit_gene_viewer = self._find_widget('txtedGeneViewer', QtWidgets.QTextEdit)
         self.push_button_reset_location = self._find_widget('pbtnResetLocation', QtWidgets.QPushButton)
+        self.label_sequence_legend = self._find_widget('lblSequenceLegend', QtWidgets.QLabel)
         self.check_box_view_exons_only = self._find_widget('chkViewExonsOnly', QtWidgets.QCheckBox)
+        # Hide the text editor since we're using the DNA feature viewer
+        self.text_edit_gene_viewer.hide()
+        try:
+            # Get the layout of the gene viewer group
+            gene_viewer_group = self.findChild(QtWidgets.QGroupBox, 'grpGeneViewer')
+            gene_viewer_layout = gene_viewer_group.layout()
+            # Find the row index of the text editor
+            text_editor_row = -1
+            for i in range(gene_viewer_layout.rowCount()):
+                item = gene_viewer_layout.itemAtPosition(i, 0)
+                if item and item.widget() == self.text_edit_gene_viewer:
+                    text_editor_row = i
+                    break
+            if text_editor_row != -1:
+                # Remove the text editor from the layout
+                gene_viewer_layout.removeWidget(self.text_edit_gene_viewer)
+                # Add DNA feature viewer in its place
+                gene_viewer_layout.addWidget(self.dna_feature_viewer, text_editor_row, 0, 1, -1)
+                # Set size policy to make the DNA viewer expand
+                self.dna_feature_viewer.setSizePolicy(
+                    QtWidgets.QSizePolicy.Policy.Expanding,
+                    QtWidgets.QSizePolicy.Policy.Expanding
+                )
+            self.dna_feature_viewer.view.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+            self.dna_feature_viewer.view.installEventFilter(self)
+            self.dna_feature_viewer.installEventFilter(self)
+            # Store current sequence for editing
+            self._current_sequence = ""
+        except Exception as e:
+            self.logger.error(f"Error in _init_grpGeneViewer: {str(e)}")
+            self.logger.error(f"Stack trace: {traceback.format_exc()}")
     def _find_widget(self, name: str, widget_type: type) -> Optional[QtWidgets.QWidget]:
         widget = self.findChild(widget_type, name)
             self.logger.warning(f"Widget '{name}' not found in UI file.")
         return widget
+    def display_guides_in_table(self, guides, suppress_updates=False):
         try:
             self._all_guides = guides
             selected_text = self.combo_box_gene.currentText()
             # First filter by position/feature
                             filtered_guides.append(guide)
                 else:
                     filtered_guides = self._all_guides
+                    self.logger.debug("No filtering applied, using all guides")
             # Apply additional filters
             final_guides = []
             # Update table with new guides
             total_rows = len(final_guides)
+            # Completely freeze UI only if not suppressing updates
+            if not suppress_updates:
+                self.setUpdatesEnabled(False)
+                self.table_guides.setUpdatesEnabled(False)
+                self.table_guides.setSortingEnabled(False)
+                self.table_guides.setVisible(False)
             try:
                 # Clear and resize table
                 guide_viewer_group.setMinimumWidth(essential_columns_width + 50)  # Add some padding for scrollbar
             finally:
+                # Re-enable UI only if not suppressing updates
+                if not suppress_updates:
+                    self.table_guides.setVisible(True)
+                    self.table_guides.setUpdatesEnabled(True)
+                    self.setUpdatesEnabled(True)
+                    self.table_guides.setSortingEnabled(True)
         except Exception as e:
             self.logger.error(f"Error in display_guides: {str(e)}")
             # Clear existing items efficiently
             self.combo_box_gene.clear()
             # Use a set to ensure uniqueness
             unique_genes = list(set(genes))
                 # Set first item without triggering updates
                 if self.combo_box_gene.count() > 0:
                     self.combo_box_gene.setCurrentIndex(0)
             # Re-enable UI updates
             self.combo_box_gene.setUpdatesEnabled(True)
     def update_gene_viewer(self, sequence, features=None):
         """Update both text editor and DNA feature viewer"""
         try:
+            # Update text editor
+            self.text_edit_gene_viewer.clear()
+            doc = QTextDocument()
+            doc.setHtml(sequence)
+            self.text_edit_gene_viewer.setDocument(doc)
+            # Get start position from line edit
+            try:
+                start_pos = int(self.line_edit_start_location.text())
+            except (ValueError, TypeError):
+                start_pos = 1
+            # Update DNA feature viewer
+            if features is None:
+                features = []
+            self.dna_feature_viewer.set_data(sequence, features, start_pos)
+        except Exception as e:
+            self.logger.error(f"Error updating gene viewer: {str(e)}")
     def select_all_guides(self, select):
         for row in range(self.table_guides.rowCount()):
             self.logger.error(f"Error showing details: {str(e)}")
             show_error(self.settings, "Error showing details", str(e))
+    def clear_highlights(self):
+        """Clear highlights in viewer"""
+        self.dna_feature_viewer.sequence_viewer.clear_highlights()
+    def eventFilter(self, obj, event):
+        """Handle key press events"""
+        if event.type() == QEvent.Type.KeyPress:
+            # Check for copy command
+            if event.matches(QKeySequence.StandardKey.Copy):
+                self._handle_copy()
+                return True
+            # Handle delete/backspace
+            if event.key() in [Qt.Key.Key_Delete, Qt.Key.Key_Backspace]:
+                return self._handle_delete()
+            # Handle only valid base pair keys
+            if event.text():
+                valid_bases = set('ATGCRYMKSWBDHVNatgcrymkswbdhvn')
+                if event.text() in valid_bases:
+                    return self._handle_insert()
+        return super().eventFilter(obj, event)
+    def _handle_copy(self):
+        """Copy selected sequence to clipboard"""
         try:
+            start = self.dna_feature_viewer.insertion_zone.selection_start
+            end = self.dna_feature_viewer.insertion_zone.current_cursor_pos
+            if start is not None and end is not None:
+                start, end = min(start, end), max(start, end)
+                # Get sequence from DNA viewer instead of stored sequence
+                sequence = self.dna_feature_viewer.sequence_viewer.sequence
+                if sequence:
+                    selected_sequence = sequence[start:end]
+                    if selected_sequence:
+                        clipboard = QApplication.clipboard()
+                        clipboard.setText(selected_sequence)
+                        self.logger.debug(f"Copied sequence: {selected_sequence}")
+                else:
+                    self.logger.warning("No sequence available to copy")
+        except Exception as e:
+            self.logger.error(f"Error copying sequence: {str(e)}")
+            self.logger.error(f"Stack trace: {traceback.format_exc()}")
+    def _handle_delete(self):
+        """Handle deletion of selected base pairs"""
+        start = self.dna_feature_viewer.insertion_zone.selection_start
+        end = self.dna_feature_viewer.insertion_zone.current_cursor_pos
+        # Check if there's no selection but there are highlighted nucleotides
+        if (start is None or end is None or start == end):
+            # Look for highlighted nucleotides
+            sequence_viewer = self.dna_feature_viewer.sequence_viewer
+            highlighted_positions = []
+            for i, nuc in enumerate(sequence_viewer.nucleotides):
+                if nuc.is_highlighted and nuc.highlight_color == QColor(100, 150, 255, 100):  # Check for selection blue
+                    # Convert nucleotide index to sequence position (divide by 2 since each base has 2 nucleotides)
+                    pos = i // 2
+                    highlighted_positions.append(pos)
+            if highlighted_positions:
+                # Use the range of highlighted positions
+                start = min(highlighted_positions)
+                end = max(highlighted_positions) + 1  # Add 1 to include the last position
+            else:
+                QMessageBox.warning(
+                    self,
+                    "No Selection",
+                    "Please select the bases to be removed and then press Delete",
+                    QMessageBox.StandardButton.Ok
+                )
+                return True
+        start, end = min(start, end), max(start, end)
+        num_bases = end - start
+        reply = QMessageBox.question(
+            self,
+            "Confirm Deletion",
+            f"Delete {num_bases} bp?",
+            QMessageBox.StandardButton.Ok | QMessageBox.StandardButton.Cancel,
+            QMessageBox.StandardButton.Cancel
+        )
+        if reply == QMessageBox.StandardButton.Ok:
+            # Store current highlights before deletion
+            guide_highlights = []
+            sequence_viewer = self.dna_feature_viewer.sequence_viewer
+            for i, nuc in enumerate(sequence_viewer.nucleotides):
+                if nuc.is_highlighted:
+                    # Only store guide highlights (red/green), not selection highlights (blue)
+                    if nuc.highlight_color not in [QColor(200, 200, 255, 100), QColor(100, 150, 255, 100)]:
+                        # Store position and color
+                        guide_highlights.append({
+                            'pos': i,
+                            'color': nuc.highlight_color,
+                            'strand': '-' if i % 2 else '+'  # Odd indices are negative strand
+                        })
+            # Create new sequence
+            new_sequence = self._current_sequence[:start] + self._current_sequence[end:]
+            self._current_sequence = new_sequence
+            # Clear all highlights before updating viewer
+            self.dna_feature_viewer.sequence_viewer.clear_highlights()
+            # Update viewer with new sequence
+            self.update_gene_viewer(new_sequence)
+            # Reapply guide highlights, adjusting positions for deleted section
+            for highlight in guide_highlights:
+                orig_pos = highlight['pos']
+                # Calculate new position after deletion
+                if orig_pos < start * 2:  # Multiply by 2 because each base has two nucleotides
+                    new_pos = orig_pos
+                elif orig_pos > end * 2:
+                    new_pos = orig_pos - ((end - start) * 2)  # Adjust for deleted section
+                else:
+                    continue  # Skip highlights in deleted region
+                # Apply highlight to new position
+                if new_pos < len(sequence_viewer.nucleotides):
+                    nuc = sequence_viewer.nucleotides[new_pos]
+                    nuc.is_highlighted = True
+                    nuc.highlight_color = highlight['color']
+                    nuc.update()
+            # Calculate cursor position coordinates
+            line_number = start // self.dna_feature_viewer.sequence_viewer.bases_per_line
+            cursor_pos_in_line = start % self.dna_feature_viewer.sequence_viewer.bases_per_line
+            # Calculate exact cursor coordinates
+            cursor_x = self.dna_feature_viewer.sequence_viewer.strand_margin + (cursor_pos_in_line * self.dna_feature_viewer.sequence_viewer.base_width)
+            cursor_y = (line_number * self.dna_feature_viewer.sequence_viewer.line_spacing) + (self.dna_feature_viewer.sequence_viewer.line_height * 0.1)
+            cursor_height = self.dna_feature_viewer.sequence_viewer.line_height * 2 + 6
+            # Position cursor at start of deleted region
+            self.dna_feature_viewer.insertion_zone.sequence_cursor.set_position(
+                cursor_x,
+                cursor_y,
+                cursor_height
+            )
+            self.dna_feature_viewer.insertion_zone.sequence_cursor.show()
+            # Update stored cursor position
+            self.dna_feature_viewer.insertion_zone.current_cursor_pos = start
+            # Clear selection states
+            self.dna_feature_viewer.sequence_viewer.selection_start = None
+            self.dna_feature_viewer.sequence_viewer.selection_end = None
+            self.dna_feature_viewer.sequence_viewer.selection_active = False
+            self.dna_feature_viewer.insertion_zone.selection_start = None
+            self.dna_feature_viewer.insertion_zone.selection_end = None
+            self.dna_feature_viewer.insertion_zone.selection_active = False
+            # Force update of the view
+            scene = self.dna_feature_viewer.scene
+            if scene is not None:
+                scene.update()
+            # Make sure view maintains focus
+            self.dna_feature_viewer.view.setFocus()
+        return True
+    def _handle_insert(self):
+        """Handle base pair insertion"""
+        cursor_pos = self.dna_feature_viewer.insertion_zone.current_cursor_pos
+        if cursor_pos is not None:
+            dialog = BaseInsertionDialog(self)
+            if dialog.exec() == QDialog.DialogCode.Accepted:
+                bases = dialog.get_bases()
+                new_sequence = (
+                    self._current_sequence[:cursor_pos] +
+                    bases +
+                    self._current_sequence[cursor_pos:]
+                )
+                self._current_sequence = new_sequence
+                # Store new cursor position before updating viewer
+                new_cursor_pos = cursor_pos + len(bases)
+                # Update viewer with new sequence
+                self.update_gene_viewer(new_sequence)
+                # Highlight the newly added bases on both strands
+                highlight_color = QColor(100, 150, 255, 100)  # Same blue as selection
+                # Highlight positive strand
+                self.dna_feature_viewer.sequence_viewer.highlight_sequence(
+                    cursor_pos,  # Start at insertion point
+                    new_cursor_pos - 1,  # End at position before new cursor
+                    highlight_color,
+                    strand='+'
+                )
+                # Highlight negative strand
+                self.dna_feature_viewer.sequence_viewer.highlight_sequence(
+                    cursor_pos,  # Start at insertion point
+                    new_cursor_pos - 1,  # End at position before new cursor
+                    highlight_color,
+                    strand='-'
+                )
+                # Calculate cursor position coordinates
+                line_number = new_cursor_pos // self.dna_feature_viewer.sequence_viewer.bases_per_line
+                cursor_pos_in_line = new_cursor_pos % self.dna_feature_viewer.sequence_viewer.bases_per_line
+                # Calculate exact cursor coordinates
+                cursor_x = self.dna_feature_viewer.sequence_viewer.strand_margin + (cursor_pos_in_line * self.dna_feature_viewer.sequence_viewer.base_width)
+                cursor_y = (line_number * self.dna_feature_viewer.sequence_viewer.line_spacing) + (self.dna_feature_viewer.sequence_viewer.line_height * 0.1)
+                cursor_height = self.dna_feature_viewer.sequence_viewer.line_height * 2 + 6
+                # Position cursor after inserted bases
+                self.dna_feature_viewer.insertion_zone.sequence_cursor.set_position(
+                    cursor_x,
+                    cursor_y,
+                    cursor_height
+                )
+                self.dna_feature_viewer.insertion_zone.sequence_cursor.show()
+                # Update stored cursor position
+                self.dna_feature_viewer.insertion_zone.current_cursor_pos = new_cursor_pos
+                # Make sure view maintains focus
+                self.dna_feature_viewer.view.setFocus()
+            return True
+    def closeEvent(self, event):
+        """Handle cleanup when window is closed"""
+        try:
+            # Clean up DNA viewer if it exists
+            if hasattr(self, 'dna_feature_viewer'):
+                self.dna_feature_viewer.closeEvent(event)
+            # Ensure all views release mouse tracking
+            for child in self.findChildren(QtWidgets.QWidget):
+                if isinstance(child, (QtWidgets.QGraphicsView, QtWidgets.QAbstractScrollArea)):
+                    child.setMouseTracking(False)
+                    child.viewport().setMouseTracking(False)
+                    if child.hasMouseTracking():
+                        child.releaseMouse()
         except Exception as e:
+            if hasattr(self, 'logger'):
+                self.logger.error(f"Error in closeEvent: {str(e)}")
+        super().closeEvent(event)

src/views/dialogs/base_insertion_dialog.py ADDED Viewed

	@@ -0,0 +1,56 @@

+from PyQt6.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit, QPushButton
+class BaseInsertionDialog(QDialog):
+    """Dialog for inserting base pairs"""
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Insert Base Pairs")
+        self.setModal(True)
+        self.valid_bases = set('ATGCRYMKSWBDHVNatgcrymkswbdhvn')
+        layout = QVBoxLayout(self)
+        label = QLabel(
+            "Enter base pairs to insert:\n"
+            "A (Adenine), T (Thymine), G (Guanine), C (Cytosine)\n"
+            "R (A/G), Y (C/T), M (A/C), K (G/T), S (G/C), W (A/T)\n"
+            "H (A/C/T), B (G/C/T), V (G/C/A), D (G/A/T), N (Any)"
+        )
+        layout.addWidget(label)
+        self.input_field = QLineEdit()
+        self.input_field.setPlaceholderText("e.g., ATGC, RYKMSWBDHVN")
+        self.input_field.textChanged.connect(self._validate_input)
+        layout.addWidget(self.input_field)
+        button_layout = QHBoxLayout()
+        self.insert_button = QPushButton("Insert")
+        self.insert_button.clicked.connect(self.accept)
+        self.insert_button.setEnabled(False)  # Disabled until valid input
+        cancel_button = QPushButton("Cancel")
+        cancel_button.clicked.connect(self.reject)
+        button_layout.addWidget(self.insert_button)
+        button_layout.addWidget(cancel_button)
+        layout.addLayout(button_layout)
+        self.setMinimumWidth(400)
+    def _validate_input(self, text):
+        """Validate input and filter invalid characters"""
+        # Remove any invalid characters
+        valid_text = ''.join(c for c in text if c in self.valid_bases)
+        # If text changed, update the field
+        if valid_text != text:
+            self.input_field.setText(valid_text)
+        # Enable/disable insert button based on input
+        self.insert_button.setEnabled(bool(valid_text))
+    def get_bases(self):
+        """Return the entered base pairs preserving case"""
+        return self.input_field.text()

src/views/dna_viewer/__init__.py ADDED Viewed

	@@ -0,0 +1 @@


1	+ # Empty file to make the directory a Python package

src/views/dna_viewer/components/__init__.py ADDED Viewed

	@@ -0,0 +1 @@


1	+ # Empty file to make the directory a Python package

src/views/dna_viewer/components/feature_viewer.py ADDED Viewed

	@@ -0,0 +1,152 @@

+from PyQt6.QtWidgets import QGraphicsObject
+from PyQt6.QtCore import Qt, QRectF, pyqtSignal, QPointF
+from PyQt6.QtGui import QBrush, QColor, QFont
+class FeatureViewer(QGraphicsObject):
+    """Component for displaying DNA features like genes and exons"""
+    cursor_position_changed = pyqtSignal(int)
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.sequence = ""
+        self.features = []
+        self.start_pos = 0
+        self.base_width = 15
+        self.bases_per_line = 70
+        self.feature_height = 20
+        self.line_height = 25
+        self.feature_spacing = 2  # Spacing between features and strands
+        self.setAcceptHoverEvents(True)
+        # Add logger
+        import logging
+        self.logger = logging.getLogger(__name__)
+    def set_data(self, sequence, features, start_pos):
+        """Set sequence and features data"""
+        self.sequence = sequence
+        self.features = sorted(features, key=lambda x: x['start'])
+        self.start_pos = start_pos
+        self.update()
+    def paint(self, painter, option, widget):
+        """Paint the features"""
+        if not self.features or not self.sequence:
+            return
+        # Process each line of sequence
+        current_pos = 0
+        while current_pos < len(self.sequence):
+            line_text = self.sequence[current_pos:current_pos + self.bases_per_line]
+            line_num = current_pos // self.bases_per_line
+            # Calculate y position to be directly below negative strand
+            y_pos = line_num * self.line_height * 2
+            feature_y = y_pos + self.line_height * 2  # Position below negative strand
+            # Calculate sequence width for this line
+            sequence_width = len(line_text) * self.base_width
+            # Draw features
+            for feature in self.features:
+                try:
+                    # Calculate relative positions within current line
+                    feature_start = feature['start'] - current_pos
+                    feature_end = feature['end'] - current_pos
+                    # Skip if feature is not in current line
+                    if feature_end < 0 or feature_start >= self.bases_per_line:
+                        continue
+                    # Clip to line boundaries
+                    feature_start = max(0, feature_start)
+                    feature_end = min(self.bases_per_line, feature_end)
+                    # Calculate pixel positions
+                    x_start = feature_start * self.base_width
+                    x_end = feature_end * self.base_width
+                    # Create rectangle for feature
+                    feature_rect = QRectF(
+                        x_start,
+                        feature_y,
+                        x_end - x_start,
+                        self.feature_height
+                    )
+                    # Set color based on feature type
+                    if feature.get('type') == 'exon':
+                        color = QColor(100, 180, 255)  # Light blue for exons
+                    else:
+                        color = QColor(255, 140, 0)  # Orange for genes
+                    # Draw feature rectangle
+                    painter.setBrush(QBrush(color))
+                    painter.setPen(Qt.PenStyle.NoPen)
+                    painter.drawRect(feature_rect)
+                    # Draw label if enough space
+                    label = feature.get('name', '')
+                    text_width = painter.fontMetrics().horizontalAdvance(label)
+                    if (x_end - x_start) > text_width:
+                        text_x = x_start + ((x_end - x_start) - text_width) / 2
+                        text_y = feature_y + self.feature_height/2 + 4
+                        painter.setPen(Qt.GlobalColor.white)
+                        painter.setFont(QFont("Arial", 8))
+                        painter.drawText(QPointF(text_x, text_y), label)
+                except Exception as e:
+                    self.logger.error(f"Error drawing feature: {str(e)}")
+                    continue
+            current_pos += self.bases_per_line
+    def boundingRect(self):
+        """Return the bounding rectangle of the component"""
+        if not self.sequence:
+            return QRectF()
+        # Calculate exact width based on sequence length
+        last_line_length = len(self.sequence) % self.bases_per_line
+        if last_line_length == 0:
+            last_line_length = self.bases_per_line
+        width = max(self.base_width * self.bases_per_line,
+                   self.base_width * last_line_length) + 100
+        # Calculate height for actual sequence lines
+        total_lines = (len(self.sequence) + self.bases_per_line - 1) // self.bases_per_line
+        height = total_lines * self.line_height * 2
+        return QRectF(0, 0, width, height)
+    def mousePressEvent(self, event):
+        """Handle mouse press to show insertion point"""
+        if event.button() == Qt.MouseButton.LeftButton:
+            # Calculate position based on click location
+            local_pos = event.pos()
+            line_number = int(local_pos.y() // (self.line_height * 2))
+            base_position = int(local_pos.x() // self.base_width)
+            # Calculate absolute position
+            position = self.start_pos + line_number * self.bases_per_line + base_position
+            # Emit cursor position
+            self.cursor_position_changed.emit(position)
+        event.accept()
+    def mouseMoveEvent(self, event):
+        """Handle mouse move to update insertion point"""
+        if event.buttons() & Qt.MouseButton.LeftButton:
+            # Calculate position based on mouse location
+            local_pos = event.pos()
+            line_number = int(local_pos.y() // (self.line_height * 2))
+            base_position = int(local_pos.x() // self.base_width)
+            # Calculate absolute position
+            position = self.start_pos + line_number * self.bases_per_line + base_position
+            # Emit cursor position
+            self.cursor_position_changed.emit(position)
+        event.accept()

src/views/dna_viewer/components/nucleotide_item.py ADDED Viewed

	@@ -0,0 +1,108 @@

+from PyQt6.QtWidgets import QGraphicsObject
+from PyQt6.QtCore import Qt, QRectF, pyqtSignal
+from PyQt6.QtGui import QFont, QColor
+class NucleotideItem(QGraphicsObject):
+    """Component for displaying individual nucleotides in the gene sequence viewer"""
+    clicked = pyqtSignal(object)
+    def __init__(self, nucleotide, x, y, width, is_uppercase=True, is_complement=False, is_padding=False, parent=None):
+        """Initialize nucleotide item
+        Args:
+            nucleotide (str): The nucleotide base (A, T, G, C)
+            x (float): X position
+            y (float): Y position
+            width (float): Width of nucleotide
+            is_uppercase (bool): Whether nucleotide should be uppercase
+            is_complement (bool): Whether this is a complement strand nucleotide
+            is_padding (bool): Whether this nucleotide is part of padding sequence
+            parent (QGraphicsObject): Parent item
+        """
+        super().__init__(parent)
+        self.nucleotide = nucleotide
+        self.setPos(x, y)
+        self.width = width
+        self.base_width = width
+        self.height = 20
+        self.is_uppercase = is_uppercase
+        self.is_complement = is_complement
+        self.is_padding = is_padding
+        self.is_highlighted = False
+        self.highlight_color = None
+        # Enable hover events
+        self.setAcceptHoverEvents(True)
+    def paint(self, painter, option, widget):
+        """Paint the nucleotide"""
+        try:
+            # Draw highlight background if highlighted
+            if self.is_highlighted and self.highlight_color:
+                painter.save()
+                painter.fillRect(self.boundingRect(), self.highlight_color)
+                painter.restore()
+            # Draw nucleotide centered
+            painter.setFont(QFont("Courier", 12))
+            # Use grey for padding sequence, black for all other nucleotides
+            if self.is_padding:
+                painter.setPen(QColor(100, 100, 100))
+            else:
+                painter.setPen(Qt.GlobalColor.black)
+            # Get complement nucleotide if needed
+            display_nucleotide = self._get_complement() if self.is_complement else self.nucleotide
+            # Draw text centered
+            painter.drawText(self.boundingRect(), Qt.AlignmentFlag.AlignCenter, display_nucleotide)
+        except Exception as e:
+            print(f"Error in paint: {str(e)}")
+    def boundingRect(self):
+        """Return the bounding rectangle for the nucleotide"""
+        return QRectF(0, 0, self.width, self.height)
+    def mousePressEvent(self, event):
+        """Handle mouse press events"""
+        if event.button() == Qt.MouseButton.LeftButton:
+            sequence_viewer = self.parent()
+            if sequence_viewer:
+                pos = sequence_viewer.get_nucleotide_position(self)
+                local_x = event.pos().x()
+                # Calculate position relative to letter boundaries
+                text_x = (self.width - self.base_width) / 2
+                relative_x = local_x - text_x
+                # Determine cursor position
+                if relative_x <= 0:  # Before letter
+                    cursor_pos = pos
+                elif relative_x >= self.base_width:  # After letter
+                    cursor_pos = pos + 1
+                else:  # On letter
+                    cursor_pos = pos + (1 if relative_x > self.base_width / 2 else 0)
+                # Update selection and cursor
+                sequence_viewer.selection_start = cursor_pos
+                sequence_viewer.selection_end = cursor_pos
+                sequence_viewer.selection_active = True
+                sequence_viewer.cursor_position_changed.emit(cursor_pos)
+                sequence_viewer._update_selection()
+                self.update()
+        event.accept()
+    def _get_complement(self):
+        """Get complement nucleotide"""
+        complement_map = {
+            'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G',
+            'a': 't', 't': 'a', 'g': 'c', 'c': 'g',
+            'K': 'M', 'M': 'K', 'R': 'Y', 'Y': 'R',
+            'k': 'm', 'm': 'k', 'r': 'y', 'y': 'r',
+            'S': 'S', 's': 's'
+        }
+        return complement_map.get(self.nucleotide, self.nucleotide)

src/views/dna_viewer/components/ruler.py ADDED Viewed

	@@ -0,0 +1,121 @@

+import logging
+from PyQt6.QtWidgets import QGraphicsScene, QGraphicsLineItem, QGraphicsSimpleTextItem
+from PyQt6.QtCore import QRectF, Qt
+from PyQt6.QtGui import QPen, QColor, QFont, QBrush
+class Ruler(QGraphicsScene):
+    """Component for displaying the ruler with position markers"""
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.logger = logging.getLogger(__name__)
+        self.base_width = 15
+        self.strand_margin = 40  # Width for 5' and 3' indicators
+        self.ruler_height = 30
+        self.ruler_color = QColor(0, 120, 215)  # Blue
+        # Set background color to match interface
+        background_color = QColor(240, 240, 240)
+        self.setBackgroundBrush(QBrush(background_color))
+        # Ensure the background fills the entire scene
+        self.setSceneRect(QRectF(0, 0, 1000, self.ruler_height - 15))
+        # Tick mark settings
+        self.major_tick_height = 10  # Height for major ticks (multiples of 10)
+        self.medium_tick_height = 7  # Height for medium ticks (multiples of 5)
+        self.minor_tick_height = 4  # Height for minor ticks
+        self.ruler_y = 15  # Y position of main ruler line
+        # Initialize tracker line as None - we'll create it when needed
+        self.tracker_line = None
+    def create_ruler(self, bases_per_line):
+        """Create ruler with position markers
+        Args:
+            bases_per_line (int): Number of bases per line in sequence viewer
+        """
+        try:
+            self.clear()  # Clear everything
+            # Create horizontal blue line aligned with sequence
+            ruler_line = QGraphicsLineItem(
+                self.strand_margin, self.ruler_y,
+                bases_per_line * self.base_width + self.strand_margin, self.ruler_y
+            )
+            ruler_line.setPen(QPen(self.ruler_color, 1))
+            self.addItem(ruler_line)
+            # Add tick marks and numbers
+            for i in range(0, bases_per_line):
+                x_pos = i * self.base_width + self.strand_margin + self.base_width/2
+                pos_1_based = i + 1
+                # Determine tick properties based on position
+                if pos_1_based % 10 == 0:  # Major ticks (every 10)
+                    tick_height = self.major_tick_height
+                    tick_start = 10
+                    # Add number
+                    text = QGraphicsSimpleTextItem(str(pos_1_based))
+                    text.setFont(QFont("Arial", 8))
+                    text_width = text.boundingRect().width()
+                    text.setPos(x_pos - text_width/2, 0)
+                    self.addItem(text)
+                elif pos_1_based % 5 == 0:  # Medium ticks (every 5)
+                    tick_height = self.medium_tick_height
+                    tick_start = 11
+                else:  # Minor ticks
+                    tick_height = self.minor_tick_height
+                    tick_start = 13
+                # Create tick mark
+                tick = QGraphicsLineItem(
+                    x_pos, tick_start,
+                    x_pos, tick_start + tick_height
+                )
+                tick.setPen(QPen(self.ruler_color, 1))
+                self.addItem(tick)
+            # Create new tracker line
+            self.tracker_line = QGraphicsLineItem()
+            pen = QPen(self.ruler_color)
+            pen.setWidth(2)
+            pen.setStyle(Qt.PenStyle.SolidLine)
+            self.tracker_line.setPen(pen)
+            self.tracker_line.setZValue(100)
+            self.tracker_line.hide()
+            self.addItem(self.tracker_line)
+        except Exception as e:
+            self.logger.error(f"Error creating ruler: {str(e)}")
+    def boundingRect(self):
+        """Return the bounding rectangle of the ruler"""
+        return self.sceneRect()
+    def update_tracker_position(self, x_pos):
+        """Update the position of the tracker line"""
+        try:
+            if self.tracker_line is None:
+                # Create tracker line if it doesn't exist
+                self.tracker_line = QGraphicsLineItem()
+                pen = QPen(self.ruler_color)
+                pen.setWidth(2)
+                pen.setStyle(Qt.PenStyle.SolidLine)
+                self.tracker_line.setPen(pen)
+                self.tracker_line.setZValue(100)
+                self.addItem(self.tracker_line)
+            # Ensure x_pos is within bounds
+            scene_rect = self.sceneRect()
+            x_pos = max(self.strand_margin, min(x_pos, scene_rect.width() - self.strand_margin))
+            # Set tracker line position
+            self.tracker_line.setLine(x_pos, 0, x_pos, self.ruler_height)
+            self.tracker_line.show()
+            self.update()
+        except Exception as e:
+            self.logger.error(f"Error updating tracker position: {str(e)}")

src/views/dna_viewer/components/sequence_cursor.py ADDED Viewed

	@@ -0,0 +1,61 @@

+from PyQt6.QtWidgets import QGraphicsLineItem
+from PyQt6.QtCore import Qt, QRectF, QPointF
+from PyQt6.QtGui import QPen, QColor, QPainter
+class SequenceCursor(QGraphicsLineItem):
+    """A vertical I-beam cursor for DNA sequence that spans between strands"""
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        # Use a solid blue line
+        self.pen = QPen(QColor(0, 100, 255))
+        self.pen.setWidth(2)
+        self.pen.setStyle(Qt.PenStyle.SolidLine)
+        self.setPen(self.pen)
+        # Keep cursor on top
+        self.setZValue(9999)
+        # Don't make cursor selectable/focusable
+        self.setAcceptHoverEvents(False)
+        self.setAcceptedMouseButtons(Qt.MouseButton.NoButton)
+        # Disable caching for immediate updates
+        self.setCacheMode(QGraphicsLineItem.CacheMode.NoCache)
+    def set_position(self, x, y, height):
+        """Position the cursor at given coordinates"""
+        self.setLine(x, y, x, y + height)
+        self.update()
+    def paint(self, painter, option, widget):
+        """Draw the I-beam cursor"""
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        # Draw vertical line
+        painter.setPen(self.pen)
+        line = self.line()
+        painter.drawLine(line)
+        # Draw small horizontal lines at top and bottom using QPointF
+        bar_width = 6
+        # Top bar
+        top_start = QPointF(line.x1() - bar_width/2, line.y1())
+        top_end = QPointF(line.x1() + bar_width/2, line.y1())
+        painter.drawLine(top_start, top_end)
+        # Bottom bar
+        bottom_start = QPointF(line.x1() - bar_width/2, line.y2())
+        bottom_end = QPointF(line.x1() + bar_width/2, line.y2())
+        painter.drawLine(bottom_start, bottom_end)
+    def boundingRect(self):
+        """Bounding rectangle for the cursor"""
+        line = self.line()
+        padding = 4
+        return QRectF(line.x1() - padding,
+                     line.y1() - padding,
+                     padding * 2,
+                     line.y2() - line.y1() + padding * 2)

src/views/dna_viewer/components/sequence_insertion_zone.py ADDED Viewed

	@@ -0,0 +1,356 @@

+from PyQt6.QtWidgets import QGraphicsObject
+from PyQt6.QtCore import Qt, QRectF, pyqtSignal, QPointF, QEvent
+from PyQt6.QtGui import QColor, QPainterPath
+from .sequence_cursor import SequenceCursor
+import logging
+class SequenceInsertionZone(QGraphicsObject):
+    """Handles the interactive zone between base pairs for insertion/deletion"""
+    insertion_point_selected = pyqtSignal(int)  # Emits position when zone is clicked
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.logger = logging.getLogger(__name__)
+        self.zone_width = 8
+        # State tracking
+        self.hover_position = None
+        self.active_zones = []  # List of (x, y, width, height) for each zone
+        self.sequence_length = 0
+        self.bases_per_line = 70 # Default value
+        self.base_width = 15
+        self.strand_margin = 40
+        self.line_height = 25
+        self.sequence_cursor = SequenceCursor(self)
+        self.sequence_cursor.hide()
+        self.current_cursor_pos = None
+        self.setAcceptHoverEvents(True)
+        self.setAcceptedMouseButtons(Qt.MouseButton.LeftButton)
+        self.setFlag(QGraphicsObject.GraphicsItemFlag.ItemIsSelectable, True)
+        self.setFlag(QGraphicsObject.GraphicsItemFlag.ItemIsFocusable, True)
+        self.setFlag(QGraphicsObject.GraphicsItemFlag.ItemClipsToShape, False)
+        self.setZValue(100)  # Keep zones above sequence
+        # Add tracking for visible area
+        self.visible_rect = QRectF()
+        self.scale_factor = 1.0
+        # Add tracking for hover state
+        self.last_valid_hover_pos = None
+        self.hover_active = False
+    def create_zones(self, sequence_length, base_width, strand_margin, line_height, bases_per_line, line_spacing=None):
+        """Create insertion zones between bases"""
+        self.active_zones.clear()
+        self.line_height = line_height
+        self.line_spacing = line_spacing if line_spacing is not None else line_height * 3
+        self.bases_per_line = bases_per_line
+        self.base_width = base_width
+        self.strand_margin = strand_margin
+        self.sequence_length = sequence_length
+        self.update()
+    def contains(self, point):
+        """Override contains to better handle hover detection"""
+        # Convert point to local coordinates if needed
+        local_point = point
+        if isinstance(point, QPointF):
+            local_point = self.mapFromScene(point)
+        # Calculate position
+        line_number = int(local_point.y() / self.line_spacing)
+        x_relative = local_point.x() - self.strand_margin
+        position_in_line = int(x_relative / self.base_width)
+        absolute_position = (line_number * self.bases_per_line) + position_in_line
+        # Calculate total lines
+        total_lines = (self.sequence_length + self.bases_per_line - 1) // self.bases_per_line
+        # Check if position is valid with more precise bounds
+        in_x_range = -self.zone_width <= x_relative <= (self.bases_per_line * self.base_width + self.zone_width)
+        in_y_range = 0 <= line_number < total_lines
+        position_valid = 0 <= absolute_position <= self.sequence_length
+        # Calculate vertical position within line with more generous zones
+        y_in_line = local_point.y() % self.line_spacing
+        # Define zones with appropriate overlap and coverage
+        zone_height = self.line_height * 1.8
+        middle_point = self.line_spacing / 2
+        # Upper zone covers from start to middle + overlap
+        upper_zone_start = 0
+        upper_zone_end = middle_point + (zone_height / 2)
+        # Lower zone covers from middle - overlap to end
+        lower_zone_start = middle_point - (zone_height / 2)
+        lower_zone_end = self.line_spacing
+        # Allow interaction in both upper and lower strand regions with overlap
+        upper_strand_zone = upper_zone_start <= y_in_line <= upper_zone_end
+        lower_strand_zone = lower_zone_start <= y_in_line <= lower_zone_end
+        in_vertical_zone = upper_strand_zone or lower_strand_zone
+        return in_x_range and in_y_range and position_valid and in_vertical_zone
+    def hoverMoveEvent(self, event):
+        """Handle hover using direct coordinate calculation"""
+        pos = event.pos()
+        if self.contains(pos):
+            # Calculate snapped position for cursor only
+            line_number = int(pos.y() / self.line_spacing)
+            x_relative = pos.x() - self.strand_margin
+            position_in_line = int(x_relative / self.base_width)
+            absolute_position = (line_number * self.bases_per_line) + position_in_line
+            # Update cursor behavior
+            if self.hover_position != absolute_position:
+                self.hover_position = absolute_position
+                self.setCursor(Qt.CursorShape.IBeamCursor)
+            # Update ruler tracker with exact mouse position - no snapping
+            if self.scene() and self.scene().parent():
+                dna_viewer = self.scene().parent()
+                if hasattr(dna_viewer, 'ruler_scene'):
+                    # Get exact mouse position in scene coordinates
+                    scene_pos = self.mapToScene(pos)
+                    # Adjust for any offset between sequence view and ruler
+                    ruler_x = scene_pos.x()
+                    # Account for margin differences between sequence and ruler
+                    margin_diff = self.strand_margin - dna_viewer.ruler_scene.strand_margin
+                    if margin_diff != 0:
+                        ruler_x -= margin_diff
+                    # Update tracker immediately
+                    dna_viewer.ruler_scene.update_tracker_position(ruler_x)
+                    # Force immediate updates
+                    dna_viewer.ruler_scene.update()
+                    dna_viewer.ruler_view.viewport().update()
+                    # Update scene for smooth rendering
+                    if self.scene():
+                        self.scene().update()
+        else:
+            if self.hover_position is not None:
+                self.hover_position = None
+                self.setCursor(Qt.CursorShape.ArrowCursor)
+                # Hide ruler tracker when not hovering
+                if self.scene() and self.scene().parent():
+                    dna_viewer = self.scene().parent()
+                    if hasattr(dna_viewer, 'ruler_scene'):
+                        dna_viewer.ruler_scene.tracker_line.hide()
+                        dna_viewer.ruler_scene.update()
+                        dna_viewer.ruler_view.viewport().update()
+        return super().hoverMoveEvent(event)
+    def mousePressEvent(self, event):
+        """Handle mouse press to only place cursor without highlighting"""
+        pos = event.pos()
+        # Calculate position relative to sequence
+        x_relative = pos.x() - self.strand_margin
+        line_number = int(pos.y() / self.line_spacing)
+        # Calculate nearest space between bases for cursor
+        raw_position = x_relative / self.base_width
+        cursor_position = round(raw_position)  # Round to nearest space
+        absolute_position = (line_number * self.bases_per_line) + cursor_position
+        # Confine cursor position within sequence boundaries
+        absolute_position = max(0, min(absolute_position, self.sequence_length))
+        cursor_position = absolute_position % self.bases_per_line
+        line_number = absolute_position // self.bases_per_line
+        # Store selection start but don't highlight yet
+        self.selection_start = absolute_position
+        # Reset selection state
+        self.selection_active = False
+        # Position cursor at nearest space between bases
+        cursor_x = self.strand_margin + (cursor_position * self.base_width)
+        cursor_y = (line_number * self.line_spacing) + (self.line_height * 0.1)
+        cursor_height = self.line_height * 2 + 5
+        # Show cursor
+        self.sequence_cursor.set_position(cursor_x, cursor_y, cursor_height)
+        self.sequence_cursor.show()
+        # Store and emit current cursor position
+        self.current_cursor_pos = absolute_position
+        # Get DNA feature viewer and emit cursor position change
+        if self.scene() and self.scene().parent():
+            dna_viewer = self.scene().parent()
+            sequence_viewer = dna_viewer.sequence_viewer
+            # Clear selection state and highlights
+            sequence_viewer.selection_start = None
+            sequence_viewer.selection_end = None
+            sequence_viewer.selection_active = False
+            # Clear selection highlights
+            selection_color = QColor(100, 150, 255, 100)
+            for nuc in sequence_viewer.nucleotides:
+                if nuc.highlight_color == selection_color:
+                    nuc.is_highlighted = False
+                    nuc.highlight_color = None
+                    nuc.update()
+            # Emit cursor position change immediately
+            sequence_viewer.cursor_position_changed.emit(absolute_position)
+        event.accept()
+    def mouseMoveEvent(self, event):
+        """Handle mouse drag for selection"""
+        # Only start selection if mouse has moved
+        if not self.selection_active:
+            # Check if mouse has moved enough to start selection
+            initial_pos = event.pos()
+            x_relative = initial_pos.x() - self.strand_margin
+            raw_position = x_relative / self.base_width
+            current_position = round(raw_position)
+            # Only activate selection if mouse has moved to a different position
+            if (current_position != self.selection_start // self.bases_per_line):
+                self.selection_active = True
+        if self.selection_active:
+            pos = event.pos()
+            # Calculate current position
+            x_relative = pos.x() - self.strand_margin
+            line_number = int(pos.y() / self.line_spacing)
+            raw_position = x_relative / self.base_width
+            cursor_position = round(raw_position)  # For cursor placement
+            # For highlighting, use the same rounding logic as cursor
+            highlight_position = cursor_position
+            # Convert to sequence positions
+            current_pos = (line_number * self.bases_per_line) + highlight_position
+            # Confine position within sequence boundaries
+            current_pos = max(0, min(current_pos, self.sequence_length))
+            cursor_position = current_pos % self.bases_per_line
+            line_number = current_pos // self.bases_per_line
+            if 0 <= current_pos <= self.sequence_length:
+                scene = self.scene()
+                if scene and scene.parent():
+                    dna_viewer = scene.parent()
+                    sequence_viewer = dna_viewer.sequence_viewer
+                    # Update ruler tracker with exact mouse position during selection
+                    if hasattr(dna_viewer, 'ruler_scene'):
+                        # Get exact mouse position in scene coordinates
+                        scene_pos = self.mapToScene(pos)
+                        # Adjust for any offset between sequence view and ruler
+                        ruler_x = scene_pos.x()
+                        # Account for margin differences between sequence and ruler
+                        margin_diff = self.strand_margin - dna_viewer.ruler_scene.strand_margin
+                        if margin_diff != 0:
+                            ruler_x -= margin_diff
+                        # Update tracker immediately
+                        dna_viewer.ruler_scene.update_tracker_position(ruler_x)
+                        dna_viewer.ruler_scene.update()
+                        dna_viewer.ruler_view.viewport().update()
+                    # Clear previous selection highlights
+                    selection_color = QColor(100, 150, 255, 100)
+                    for nuc in sequence_viewer.nucleotides:
+                        if nuc.highlight_color == selection_color:
+                            nuc.is_highlighted = False
+                            nuc.highlight_color = None
+                            nuc.update()
+                    # Determine selection range
+                    if current_pos >= self.selection_start:
+                        start = self.selection_start
+                        end = current_pos - 1
+                    else:
+                        start = current_pos
+                        end = self.selection_start - 1
+                    try:
+                        # Only highlight if there's a valid range
+                        if start <= end:
+                            for base_idx in range(start, end + 1):
+                                pos_strand_idx = base_idx * 2
+                                neg_strand_idx = base_idx * 2 + 1
+                                for idx in [pos_strand_idx, neg_strand_idx]:
+                                    if idx < len(sequence_viewer.nucleotides):
+                                        nuc = sequence_viewer.nucleotides[idx]
+                                        if not nuc.is_highlighted or nuc.highlight_color == selection_color:
+                                            nuc.is_highlighted = True
+                                            nuc.highlight_color = selection_color
+                                            nuc.update()
+                            # Emit selection signal with adjusted end position for display
+                            absolute_start = dna_viewer._original_start_pos + start + 1  # Add 1 only for display
+                            absolute_end = dna_viewer._original_start_pos + end + 1  # Add 1 only for display
+                            sequence_viewer.sequence_selected.emit(absolute_start, absolute_end)
+                        # Update scene and cursor
+                        if scene:
+                            scene.update()
+                        # Position cursor at nearest space between bases
+                        cursor_x = self.strand_margin + (cursor_position * self.base_width)
+                        cursor_y = (line_number * self.line_spacing) + (self.line_height * 0.1)
+                        cursor_height = self.line_height * 2 + 5
+                        self.sequence_cursor.set_position(cursor_x, cursor_y, cursor_height)
+                        self.sequence_cursor.show()
+                        self.current_cursor_pos = current_pos
+                    except Exception as e:
+                        print(f"Error highlighting: {str(e)}")
+            event.accept()
+    def mouseReleaseEvent(self, event):
+        """Handle mouse release to end selection"""
+        if self.selection_active:
+            self.selection_active = False
+            # Emit the final selection position
+            if hasattr(self, 'selection_start') and self.selection_start is not None:
+                self.insertion_point_selected.emit(self.selection_start)
+            event.accept()
+    def boundingRect(self):
+        """Return bounding rectangle for entire sequence area"""
+        if not hasattr(self, 'sequence_length') or self.sequence_length == 0:
+            return QRectF(0, 0, 1, 1)  # Return minimal rect if no sequence
+        total_lines = (self.sequence_length + self.bases_per_line - 1) // self.bases_per_line
+        width = self.strand_margin * 2 + (self.bases_per_line * self.base_width)
+        height = total_lines * self.line_spacing
+        # Add padding
+        padding = 20
+        return QRectF(-padding, -padding, width + 2*padding, height + 2*padding)
+    def paint(self, painter, option, widget):
+        """Paint method required by QGraphicsObject"""
+        pass

src/views/dna_viewer/components/sequence_viewer.py ADDED Viewed

	@@ -0,0 +1,438 @@

+import traceback
+from PyQt6.QtWidgets import QGraphicsObject, QApplication, QGraphicsSimpleTextItem, QGraphicsLineItem
+from PyQt6.QtCore import Qt, QRectF, pyqtSignal
+from PyQt6.QtGui import QPen, QFont, QColor
+from .nucleotide_item import NucleotideItem
+import logging
+class SequenceViewer(QGraphicsObject):
+    """Component for displaying and interacting with DNA sequence"""
+    sequence_selected = pyqtSignal(int, int)  # Emit start and end positions
+    cursor_position_changed = pyqtSignal(int)  # Emit cursor position
+    def __init__(self, parent=None, logger=None):
+        super().__init__(parent)
+        self.logger = logging.getLogger(__name__)
+        self._init_properties()
+        self._init_graphics_storage()
+    def _init_properties(self):
+        """Initialize properties"""
+        # Layout properties
+        self.strand_margin = 40
+        self.base_width = 15
+        self.bases_per_line = 70
+        self.line_height = 25
+        self.line_spacing = 80
+        # Sequence properties
+        self.sequence = ""
+        self.start_pos = 0
+        # Selection properties
+        self.selection_start = None
+        self.selection_end = None
+        self.drag_start_pos = None
+        self.selection_active = False
+        # Cursor properties
+        self.cursor_pos = None
+        # Clipboard
+        self.clipboard = QApplication.clipboard()
+        # Add tracking for cleared selection highlights
+        self.cleared_selection_positions = set()  # Track positions where selection was cleared
+    def _init_graphics_storage(self):
+        """Initialize storage for graphics items"""
+        self.nucleotides = []
+        self.highlighted_regions = []
+        self.nucleotide_map = {'+': [], '-': []}
+        self.plot_lines = []
+        self.tick_lines = []
+    def set_data(self, sequence, start_pos=None):
+        """Set sequence data and create nucleotide items"""
+        try:
+            if not sequence:
+                self.logger.warning("Empty sequence provided")
+                return
+            self.sequence = sequence
+            self.start_pos = start_pos if start_pos is not None else 0
+            # Store current highlights, excluding cleared selection highlights
+            current_highlights = []
+            selection_blue = QColor(100, 150, 255, 100)
+            for nuc in self.nucleotides:
+                if nuc.is_highlighted:
+                    idx = self.get_nucleotide_position(nuc)
+                    pos = idx // 2  # Convert to sequence position
+                    # Only store if it's not a selection highlight that was cleared
+                    if nuc.highlight_color != selection_blue or pos not in self.cleared_selection_positions:
+                        current_highlights.append({
+                            'position': pos,
+                            'color': nuc.highlight_color
+                        })
+            # Batch update
+            if self.scene():
+                views = self.scene().views()
+                for view in views:
+                    view.setUpdatesEnabled(False)
+            try:
+                # Create display
+                self._create_display()
+                # Reapply highlights, excluding cleared selections
+                for highlight in current_highlights:
+                    pos = highlight['position']
+                    color = highlight['color']
+                    # Skip if this was a cleared selection
+                    if color == selection_blue and pos in self.cleared_selection_positions:
+                        continue
+                    pos_strand_idx = pos * 2
+                    neg_strand_idx = pos * 2 + 1
+                    for idx in [pos_strand_idx, neg_strand_idx]:
+                        if idx < len(self.nucleotides):
+                            nuc = self.nucleotides[idx]
+                            nuc.is_highlighted = True
+                            nuc.highlight_color = color
+                            nuc.update()
+            finally:
+                # Re-enable updates
+                if self.scene():
+                    for view in views:
+                        view.setUpdatesEnabled(True)
+                        view.viewport().update()
+        except Exception as e:
+            self.logger.error(f"Error in set_data: {str(e)}")
+    def _create_display(self):
+        try:
+            # Clear existing items
+            self.cleanup_graphics()
+            total_lines = (len(self.sequence) + self.bases_per_line - 1) // self.bases_per_line
+            nucleotides_batch = []
+            plot_lines_batch = []
+            tick_lines_batch = []
+            position_numbers = []
+            current_pos = 0
+            while current_pos < len(self.sequence):
+                remaining_bases = len(self.sequence) - current_pos
+                bases_this_line = min(self.bases_per_line, remaining_bases)
+                line_text = self.sequence[current_pos:current_pos + bases_this_line]
+                line_num = current_pos // self.bases_per_line
+                y_pos = line_num * self.line_spacing
+                # Create nucleotides for this line
+                for i, nuc in enumerate(line_text):
+                    x_pos = i * self.base_width + self.strand_margin
+                    # Calculate absolute position in sequence
+                    abs_pos = current_pos + i
+                    # Determine if this nucleotide is part of padding
+                    # Only consider it padding if it's at the start or end of the sequence
+                    is_padding = (nuc.islower() and nuc in 'atgc' and
+                                (abs_pos < 30 or abs_pos >= len(self.sequence) - 30))
+                    # Create positive strand nucleotide
+                    nuc_item = NucleotideItem(
+                        nucleotide=nuc,
+                        x=x_pos,
+                        y=y_pos + self.line_height * 0.1,
+                        width=self.base_width,
+                        is_uppercase=nuc.isupper(),
+                        is_padding=is_padding,
+                        parent=self
+                    )
+                    nucleotides_batch.append(nuc_item)
+                    # Create complement strand nucleotide
+                    complement_item = NucleotideItem(
+                        nucleotide=nuc,
+                        x=x_pos,
+                        y=y_pos + self.line_height * 1.45,
+                        width=self.base_width,
+                        is_uppercase=nuc.isupper(),
+                        is_complement=True,
+                        is_padding=is_padding,
+                        parent=self
+                    )
+                    nucleotides_batch.append(complement_item)
+                # Create plot line
+                plot_y = y_pos + self.line_height * 1.15
+                plot_line = QGraphicsLineItem(
+                    self.strand_margin,
+                    plot_y,
+                    self.strand_margin + bases_this_line * self.base_width,
+                    plot_y,
+                    self
+                )
+                plot_line.setPen(QPen(Qt.GlobalColor.black, 1))
+                plot_lines_batch.append(plot_line)
+                # Add position number at end of line
+                end_pos = str(self.start_pos + current_pos + bases_this_line)
+                pos_item = QGraphicsSimpleTextItem(end_pos, self)
+                pos_item.setFont(QFont("Courier", 12))
+                # Position text with fixed offset
+                extra_spacing = 25 if line_num == total_lines - 1 else 0
+                pos_x = self.strand_margin + (bases_this_line * self.base_width) + extra_spacing + 10
+                pos_y = plot_y - pos_item.boundingRect().height()/2
+                pos_item.setPos(pos_x, pos_y)
+                position_numbers.append(pos_item)
+                # Create tick marks
+                for i in range(bases_this_line):
+                    x_pos = i * self.base_width + self.strand_margin
+                    pos_1_based = current_pos + i + 1
+                    tick_height = 12 if (i == 0 and current_pos == 0) or \
+                                 (i == bases_this_line - 1 and current_pos + bases_this_line == len(self.sequence)) else \
+                                 10 if pos_1_based % 10 == 0 else \
+                                 8 if pos_1_based % 5 == 0 else 5
+                    tick = QGraphicsLineItem(
+                        x_pos + self.base_width/2,
+                        plot_y - tick_height/2,
+                        x_pos + self.base_width/2,
+                        plot_y + tick_height/2,
+                        self
+                    )
+                    tick.setPen(QPen(Qt.GlobalColor.black, 1))
+                    tick_lines_batch.append(tick)
+                current_pos += bases_this_line
+            # Add all items to scene in batches
+            self.nucleotides = nucleotides_batch
+            self.plot_lines = plot_lines_batch
+            self.tick_lines = tick_lines_batch
+            # Add strand indicators and position numbers
+            self._add_strand_indicators(total_lines)
+        except Exception as e:
+            self.logger.error(f"Error in create optimized display: {str(e)}")
+    def _add_strand_indicators(self, total_lines):
+        # Add first line indicators
+        five_prime_pos = QGraphicsSimpleTextItem("5'", self)
+        five_prime_pos.setFont(QFont("Arial", 10))
+        five_prime_pos.setPos(0, self.line_height * 0.26)
+        three_prime_neg = QGraphicsSimpleTextItem("3'", self)
+        three_prime_neg.setFont(QFont("Arial", 10))
+        three_prime_neg.setPos(0, self.line_height * 1.58)
+        # Add last line indicators
+        last_line_width = (len(self.sequence) % self.bases_per_line) * self.base_width
+        if last_line_width == 0:
+            last_line_width = self.bases_per_line * self.base_width
+        three_prime_pos = QGraphicsSimpleTextItem("3'", self)
+        three_prime_pos.setFont(QFont("Arial", 10))
+        three_prime_pos.setPos(
+            last_line_width + self.strand_margin + 20,
+            (total_lines - 1) * self.line_spacing + self.line_height * 0.26
+        )
+        five_prime_neg = QGraphicsSimpleTextItem("5'", self)
+        five_prime_neg.setFont(QFont("Arial", 10))
+        five_prime_neg.setPos(
+            last_line_width + self.strand_margin + 20,
+            (total_lines - 1) * self.line_spacing + self.line_height * 1.58
+        )
+    def cleanup_graphics(self):
+        """Clean up all graphics items"""
+        try:
+            # Remove plot lines
+            for line in self.plot_lines:
+                if line.scene():
+                    line.scene().removeItem(line)
+            self.plot_lines.clear()
+            # Remove tick lines
+            for line in self.tick_lines:
+                if line.scene():
+                    line.scene().removeItem(line)
+            self.tick_lines.clear()
+            # Remove nucleotides
+            for nuc in self.nucleotides:
+                if nuc.scene():
+                    nuc.scene().removeItem(nuc)
+            self.nucleotides.clear()
+            # Remove all text items (including position numbers)
+            for item in self.childItems():
+                if isinstance(item, QGraphicsSimpleTextItem):
+                    if item.scene():
+                        item.scene().removeItem(item)
+            # Clear nucleotide maps but preserve highlights
+            self.nucleotide_map['+'].clear()
+            self.nucleotide_map['-'].clear()
+            self.logger.debug("Cleaned up all graphics items")
+        except Exception as e:
+            self.logger.error(f"Error in cleanup_graphics: {str(e)}")
+    def highlight_sequence(self, start_pos, end_pos, color, strand='+'):
+        """Highlight sequence with proper strand handling"""
+        try:
+            # Store highlight information
+            self.highlighted_regions.append((start_pos, end_pos, color, strand))
+            # Calculate which lines contain the sequence
+            start_line = start_pos // self.bases_per_line
+            end_line = end_pos // self.bases_per_line
+            # Calculate positions within lines
+            start_pos_in_line = start_pos % self.bases_per_line
+            end_pos_in_line = end_pos % self.bases_per_line
+            self.logger.debug(f"Highlighting from line {start_line} to {end_line}")
+            self.logger.debug(f"Start pos in line: {start_pos_in_line}, End pos in line: {end_pos_in_line}")
+            # For each line that contains part of the sequence
+            for line_num in range(start_line, end_line + 1):
+                # Calculate start and end positions for this line
+                line_start = start_pos_in_line if line_num == start_line else 0
+                line_end = end_pos_in_line if line_num == end_line else self.bases_per_line - 1
+                # Calculate base indices for this line
+                base_start = line_num * self.bases_per_line + line_start
+                base_end = line_num * self.bases_per_line + line_end
+                # Highlight nucleotides
+                for i in range(base_start, base_end + 1):
+                    if i >= len(self.nucleotides):
+                        break
+                    # For negative strand, highlight both strands' nucleotides
+                    if strand == '-':
+                        # Highlight negative strand nucleotide
+                        neg_idx = i * 2 + 1  # Odd indices for negative strand
+                        if neg_idx < len(self.nucleotides):
+                            nuc = self.nucleotides[neg_idx]
+                            nuc.is_highlighted = True
+                            nuc.highlight_color = color
+                            nuc.update()
+                    else:
+                        # Highlight positive strand nucleotide
+                        pos_idx = i * 2  # Even indices for positive strand
+                        if pos_idx < len(self.nucleotides):
+                            nuc = self.nucleotides[pos_idx]
+                            nuc.is_highlighted = True
+                            nuc.highlight_color = color
+                            nuc.update()
+            # Force scene update
+            if self.scene():
+                self.scene().update()
+            self.logger.debug(f"Highlighted sequence on strand {strand} from {start_pos} to {end_pos}")
+        except Exception as e:
+            self.logger.error(f"Error in highlight_sequence: {str(e)}")
+            self.logger.error(f"Stack trace: {traceback.format_exc()}")
+    def clear_highlights(self):
+        """Clear all highlights with optimized rendering"""
+        try:
+            # Get view and disable updates
+            view = None
+            if self.scene():
+                views = self.scene().views()
+                if views:
+                    view = views[0]
+                    view.setUpdatesEnabled(False)
+            try:
+                self.highlighted_regions.clear()
+                # Batch collect nucleotides that need updating
+                nucleotides_to_update = []
+                for nuc in self.nucleotides:
+                    if nuc.is_highlighted:
+                        nuc.is_highlighted = False
+                        nuc.highlight_color = None
+                        nucleotides_to_update.append(nuc)
+                # Update all nucleotides in a single batch
+                if nucleotides_to_update:
+                    # Use prepareGeometryChange for better performance
+                    for nuc in nucleotides_to_update:
+                        nuc.prepareGeometryChange()
+                    # Force a single scene update
+                    if self.scene():
+                        self.scene().update()
+            finally:
+                # Re-enable view updates
+                if view:
+                    view.setUpdatesEnabled(True)
+                    view.viewport().update()
+        except Exception as e:
+            self.logger.error(f"Error in clear_highlights: {str(e)}")
+            # Make sure view updates are re-enabled
+            if self.scene():
+                views = self.scene().views()
+                if views:
+                    views[0].setUpdatesEnabled(True)
+                    views[0].viewport().update()
+    def get_nucleotide_position(self, nucleotide):
+        """Get the position of a nucleotide in the sequence"""
+        try:
+            idx = self.nucleotides.index(nucleotide)
+            return idx
+        except ValueError:
+            return -1
+    def boundingRect(self):
+        """Return the bounding rectangle"""
+        if not self.sequence:
+            return QRectF(0, 0, 100, 100)  # Return a default size when empty
+        # Calculate total width including margins
+        width = (self.base_width * self.bases_per_line) + (self.strand_margin * 2)
+        # Calculate height using line spacing
+        total_lines = (len(self.sequence) + self.bases_per_line - 1) // self.bases_per_line
+        height = total_lines * self.line_spacing
+        # Add some padding
+        height += 50
+        width += 50
+        return QRectF(0, 0, width, height)
+    def paint(self, painter, option, widget):
+        """Paint method required by QGraphicsObject"""
+        pass

src/views/dna_viewer/dna_feature_viewer.py ADDED Viewed

	@@ -0,0 +1,309 @@

+from PyQt6.QtWidgets import (QWidget, QVBoxLayout, QGraphicsView, QGraphicsScene,
+                            QLabel, QFrame)
+from PyQt6.QtCore import Qt, pyqtSignal
+from PyQt6.QtGui import QBrush, QColor
+from .components.sequence_viewer import SequenceViewer
+from .components.feature_viewer import FeatureViewer
+from .components.ruler import Ruler
+from .components.sequence_insertion_zone import SequenceInsertionZone
+import logging
+import traceback
+class DNAFeatureViewer(QWidget):
+    """Main widget for displaying DNA sequences"""
+    sequence_selected = pyqtSignal(int, int)  # Emit start and end positions
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        # Get logger from parent or global settings
+        if parent and hasattr(parent, 'logger'):
+            self.logger = parent.logger
+        else:
+            self.logger = logging.getLogger(__name__)
+        # Create layout
+        self.layout = QVBoxLayout(self)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+        self.layout.setSpacing(0)
+        # Initialize components
+        self._init_views()
+        self._init_components()
+        self._init_status_panel()
+        self._init_connections()
+        # Set focus policy for the widget itself
+        self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+        self.setFocus()
+    def _init_views(self):
+        """Initialize graphics views"""
+        # Create ruler view
+        self.ruler_view = QGraphicsView()
+        self.ruler_scene = Ruler()
+        self.ruler_view.setScene(self.ruler_scene)
+        self.ruler_view.setFixedHeight(25)
+        self.ruler_view.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.ruler_view.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.ruler_view.setViewportMargins(0, 0, 0, 0)
+        self.ruler_view.setFrameStyle(0)
+        self.ruler_view.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop)
+        self.ruler_view.setEnabled(False)  # Disable all user interaction with ruler
+        # Set background color for both view and viewport
+        background_color = QColor(240, 240, 240)
+        self.ruler_view.setBackgroundBrush(QBrush(background_color))
+        self.ruler_view.viewport().setStyleSheet(f"background-color: rgb({background_color.red()}, {background_color.green()}, {background_color.blue()})")
+        self.ruler_view.setAutoFillBackground(True)
+        # Create main view with proper event handling
+        self.view = QGraphicsView()
+        self.scene = QGraphicsScene(self)
+        self.view.setScene(self.scene)
+        # Add these lines to remove the frame from main view
+        self.view.setFrameStyle(0)  # Remove frame
+        self.view.setViewportMargins(0, 0, 0, 0)  # Remove margins
+        # Set alignment to force left anchoring
+        self.view.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop)
+        # Make sure scene events are handled
+        self.scene.setItemIndexMethod(QGraphicsScene.ItemIndexMethod.NoIndex)
+    def _init_components(self):
+        try:
+            # Create sequence and feature viewers
+            if not hasattr(self, 'sequence_viewer'):
+                self.sequence_viewer = SequenceViewer(logger=self.logger)
+                # Reduce left margin/padding
+                self.sequence_viewer.strand_margin = 20
+                self.scene.addItem(self.sequence_viewer)
+            if not hasattr(self, 'feature_viewer'):
+                # Create feature viewer and add to scene
+                self.feature_viewer = FeatureViewer()
+                # Match margin with sequence viewer
+                self.feature_viewer.strand_margin = 20
+                self.scene.addItem(self.feature_viewer)
+            # Add sequence insertion zone
+            if not hasattr(self, 'insertion_zone'):
+                self.insertion_zone = SequenceInsertionZone()
+                # Match margin with sequence viewer
+                self.insertion_zone.strand_margin = 20
+            self.scene.addItem(self.insertion_zone)
+            # Add views to layout
+            self.layout.insertWidget(0, self.ruler_view)
+            self.layout.addWidget(self.view)
+        except Exception as e:
+            self.logger.error(f"Error in _init_components: {str(e)}")
+            self.logger.error(f"Stack trace: {traceback.format_exc()}")
+    def _init_status_panel(self):
+        """Initialize status panel"""
+        self.status_panel = QLabel()
+        self.status_panel.setFrameStyle(QFrame.Shape.Panel | QFrame.Shadow.Sunken)
+        self.status_panel.setStyleSheet("""
+            QLabel {
+                background-color: #f0f0f0;
+                padding: 5px;
+                border-top: 1px solid #ccc;
+                min-height: 20px;
+            }
+        """)
+        self.layout.addWidget(self.status_panel)
+    def _init_connections(self):
+        """Initialize signal connections"""
+        # Connect sequence viewer signals
+        self.sequence_viewer.sequence_selected.connect(self._on_sequence_selected)
+        self.sequence_viewer.cursor_position_changed.connect(self._on_cursor_position_changed)
+        # Connect feature viewer signals
+        self.feature_viewer.cursor_position_changed.connect(self._on_cursor_position_changed)
+        # Add viewport resize handling
+        self.view.viewport().installEventFilter(self)
+    def set_data(self, sequence, features=None, start_pos=None):
+        """Set sequence and feature data"""
+        try:
+            if start_pos is None:
+                start_pos = 0
+            # self.logger.debug(f"Features: {features[:2] if features else None}")
+            # Store original start position for status panel
+            self._original_start_pos = start_pos
+            # Update components
+            self.sequence_viewer.set_data(sequence, start_pos)
+            if features is not None:
+                self.feature_viewer.set_data(sequence, features, start_pos)
+            # Update insertion zone
+            self.insertion_zone.create_zones(
+                sequence_length=len(sequence),
+                base_width=self.sequence_viewer.base_width,
+                strand_margin=self.sequence_viewer.strand_margin,
+                line_height=self.sequence_viewer.line_height,
+                bases_per_line=self.sequence_viewer.bases_per_line,
+                line_spacing=self.sequence_viewer.line_spacing
+            )
+            # Position components
+            self.feature_viewer.setY(0)
+            self.insertion_zone.setY(0)
+            # Update scene rect
+            combined_rect = self.sequence_viewer.boundingRect().united(
+                self.feature_viewer.boundingRect()
+            ).united(
+                self.insertion_zone.boundingRect()
+            )
+            self.scene.setSceneRect(combined_rect)
+            # Update ruler
+            self.ruler_scene.create_ruler(self.sequence_viewer.bases_per_line)
+            # Update status panel with original gene positions
+            sequence_length = len(sequence) if sequence else 0
+            self.status_panel.setText(
+                f"Showing: {self._original_start_pos}...{self._original_start_pos + sequence_length} = {sequence_length} bp"
+            )
+            self.update()
+            self.logger.debug("Finished setting data")
+        except Exception as e:
+            self.logger.error(f"Error setting data: {str(e)}")
+            self.logger.error(f"Stack trace: {traceback.format_exc()}")
+    def _on_sequence_selected(self, start_pos, end_pos):
+        """Handle sequence selection"""
+        try:
+            # Calculate selected length
+            selected_length = end_pos - start_pos + 1
+            # Update only the status panel
+            self.status_panel.setText(f"Selected: {start_pos}...{end_pos} = {selected_length} bp")
+            # Emit signal without updating line edits
+            self.sequence_selected.emit(start_pos, end_pos)
+        except Exception as e:
+            self.logger.error(f"Error handling sequence selection: {str(e)}")
+    def _on_cursor_position_changed(self, position):
+        """Handle cursor position changes"""
+        try:
+            if position >= 0:
+                # Convert position to be relative to gene's actual start position
+                absolute_position = self._original_start_pos + position
+                self.status_panel.setText(f"Insertion Point: {absolute_position}")
+                self.logger.debug(f"Cursor position changed to absolute position: {absolute_position}")
+            else:
+                # Reset to showing current sequence range
+                if hasattr(self, 'sequence_viewer'):
+                    sequence = self.sequence_viewer.sequence
+                    sequence_length = len(sequence)
+                    self.status_panel.setText(
+                        f"Showing: {self._original_start_pos}...{self._original_start_pos + sequence_length} = {sequence_length} bp"
+                    )
+        except Exception as e:
+            self.logger.error(f"Error handling cursor position change: {str(e)}")
+    def eventFilter(self, obj, event):
+        """Handle viewport resize events"""
+        if obj == self.view.viewport() and event.type() == event.Type.Resize:
+            try:
+                viewport_width = event.size().width()
+                margin = 100
+                available_width = viewport_width - margin
+                base_width = self.sequence_viewer.base_width
+                max_bases = (available_width // base_width)
+                new_bases = (max_bases // 10) * 10
+                new_bases = max(10, min(new_bases, 200))
+                if new_bases != self.sequence_viewer.bases_per_line:
+                    # Store current sequence and features
+                    current_sequence = self.sequence_viewer.sequence
+                    current_start = self.sequence_viewer.start_pos
+                    # Store only guide highlights (red/green), not selection highlights (blue)
+                    current_highlights = []
+                    selection_blue = QColor(100, 150, 255, 100)
+                    for nuc in self.sequence_viewer.nucleotides:
+                        if nuc.is_highlighted and nuc.highlight_color != selection_blue:
+                            idx = self.sequence_viewer.get_nucleotide_position(nuc)
+                            current_highlights.append({
+                                'position': idx // 2,
+                                'color': nuc.highlight_color
+                            })
+                    # Store cursor position
+                    cursor_sequence_pos = None
+                    if hasattr(self.insertion_zone, 'current_cursor_pos'):
+                        cursor_sequence_pos = self.insertion_zone.current_cursor_pos
+                    try:
+                        # Update bases per line
+                        self.sequence_viewer.bases_per_line = new_bases
+                        self.feature_viewer.bases_per_line = new_bases
+                        # Update components
+                        self.set_data(current_sequence, None, current_start)
+                        # Reapply only guide highlights
+                        for highlight in current_highlights:
+                            pos = highlight['position']
+                            pos_strand_idx = pos * 2
+                            neg_strand_idx = pos * 2 + 1
+                            for idx in [pos_strand_idx, neg_strand_idx]:
+                                if idx < len(self.sequence_viewer.nucleotides):
+                                    nuc = self.sequence_viewer.nucleotides[idx]
+                                    nuc.is_highlighted = True
+                                    nuc.highlight_color = highlight['color']
+                                    nuc.update()
+                        # Restore cursor position
+                        if cursor_sequence_pos is not None:
+                            # Calculate new visual position based on sequence position
+                            line_number = cursor_sequence_pos // new_bases
+                            pos_in_line = cursor_sequence_pos % new_bases
+                            # Calculate exact pixel coordinates for cursor
+                            cursor_x = self.sequence_viewer.strand_margin + (pos_in_line * self.sequence_viewer.base_width)
+                            cursor_y = (line_number * self.sequence_viewer.line_spacing) + (self.sequence_viewer.line_height * 0.1)
+                            cursor_height = self.sequence_viewer.line_height * 2 + 5
+                            # Update cursor position
+                            if hasattr(self.insertion_zone, 'sequence_cursor'):
+                                self.insertion_zone.sequence_cursor.set_position(cursor_x, cursor_y, cursor_height)
+                                self.insertion_zone.sequence_cursor.show()
+                                self.insertion_zone.current_cursor_pos = cursor_sequence_pos
+                        # Update ruler
+                        self.ruler_scene.create_ruler(new_bases)
+                        # Update scroll positions
+                        scroll_value = self.view.horizontalScrollBar().value()
+                        self.ruler_view.horizontalScrollBar().setValue(scroll_value)
+                    finally:
+                        # Force immediate update
+                        self.view.viewport().update()
+                        self.ruler_view.viewport().update()
+            except Exception as e:
+                self.logger.error(f"Error handling resize event: {str(e)}")
+        return super().eventFilter(obj, event)

January 3rd, 2025

Goal

Hypothesis

Expected Results

Results

Next Steps